Node Range - Lazy Sequence Generator

Common errors

• ReferenceError: range is not defined

  cause The `range` function is not globally available and must be imported.
  fix Add `const range = require('node-range');` at the top of your CommonJS module.

• TypeError: require(...) is not a function

  cause This error can occur if `node-range` does not export a function directly, or if the `require` call is incorrectly structured.
  fix Ensure you are calling the result of `require('node-range')` as a function: `const range = require('node-range'); const myRange = range(1, 10);`

• TypeError: range(...).map is not a function

  cause This suggests that the object returned by `range(start, end)` is not the expected range instance with the `.map` method, likely due to an incorrect import or module resolution issue in an incompatible environment.
  fix Verify that `require('node-range')` successfully resolves to the intended package and that you are using it in a compatible CommonJS Node.js environment. Consider using `console.log(typeof require('node-range'));` to inspect the export.

• ERR_REQUIRE_ESM

  cause Attempting to `require()` an ES module from a CommonJS module, or trying to `import` a CommonJS module in a pure ESM context without proper interoperability settings.
  fix This package is CommonJS-only. If you are in an ES module environment, you must dynamically import it using `import('node-range').then(module => { const range = module; ... });` or configure your build system for CJS-ESM interop. However, migration to a modern library is strongly advised.

Warnings

• breaking The `node-range` package is abandoned and has not been updated since January 2015. It is highly likely to be incompatible with modern Node.js versions (e.g., Node.js v14+), especially regarding ES Modules, and may contain unpatched security vulnerabilities.
  Fix: Migrate to a actively maintained lazy sequence or range generation library that supports modern JavaScript and Node.js versions, such as a utility from a functional programming library (e.g., Lodash, Ramda) or a dedicated iterator library.
• gotcha This package is CommonJS-only and cannot be directly imported using ES module syntax (`import ... from 'node-range';`) in pure ESM Node.js projects without specific loaders or build tool configurations.
  Fix: In CommonJS modules, use `const range = require('node-range');`. In ES modules, you might need dynamic import (`import('node-range').then(...)`) or a transpilation step, though switching to a modern library is recommended.
• gotcha The README's claim that `node-range` is "Faster than Array.map" might no longer be true in many scenarios. Modern V8 engine optimizations in Node.js have significantly improved the performance of native array methods, potentially making them competitive or even faster than this older, unmaintained lazy implementation.
  Fix: Benchmark performance critically for your specific use case against modern JavaScript alternatives and native array methods before relying on this package's performance claims.
• gotcha There are no TypeScript type definitions (`.d.ts` files) available for `node-range`. Using this package in a TypeScript project will result in type errors and a lack of intelligent code completion and type checking.
  Fix: Consider writing custom type declarations or, preferably, migrating to a modern, type-safe alternative. Alternatively, disable type checking for this specific import if the project accepts the risk.

Install

• npm install node-range npm
• yarn add node-range yarn
• pnpm add node-range pnpm

Imports

• range
  wrong:

  import range from 'node-range';

  correct:

  const range = require('node-range');

  This package is CommonJS-only and does not provide an ESM export. Direct `import` statements will fail in pure ESM environments.
• range
  wrong:

  range(1, 11);

  correct:

  const range = require('node-range');
  // Then use range(start, end)

  The `range` function is not exposed globally. It must be explicitly imported via `require`.
• Range function result
  wrong:

  const rangeInstance = new (require('node-range'))(1, 11);

  correct:

  const rangeInstance = require('node-range')(1, 11);

  The package exports a function directly, which you call with arguments to get a range instance. It is not a class to be instantiated with `new`.

Quickstart

This quickstart demonstrates creating lazy numerical ranges, applying transformations with `map` (lazy and eager), iterating with `forEach` for synchronous operations, and `forEachAsync` for non-blocking iteration using callbacks.

const range = require('node-range');

console.log('--- Lazy Map Example ---');
// Generate a lazy range from 1 to 10 (exclusive of 11), and map each element
// The array is only materialized when needed (e.g., by console.log or when iteration completes)
const mappedArr = range(1, 11).map(function(i) {
    return i * 5;
});
console.log('Result of lazy map:', mappedArr);

console.log('\n--- To Array and Map Example ---');
// Convert to an array first, then use standard Array.prototype.map
const toArrayAndMap = range(1, 11).toArray().map(function(i) {
    return i * 2;
});
console.log('Result of toArray().map:', toArrayAndMap);

console.log('\n--- Synchronous ForEach Example ---');
// Execute a function for each item in the range without returning an array
range(1, 5).forEach(function(i) {
    console.log('forEach sync:', Math.pow(i, 2));
});

console.log('\n--- Asynchronous ForEach (Callback-based) Example ---');
// Execute a function asynchronously for each item (callback-based)
// Note: This is non-blocking but uses older callback patterns
range(1, 3).forEachAsync(function(i) {
    console.log('forEachAsync num:', i);
});
console.log('This should come first (demonstrating async nature)');