Array Reducing Utilities

2.1.0 · abandoned · verified Sun Apr 19

The `arrayreduce` package, currently at version 2.1.0, provides a small collection of pre-built, reusable reducer functions designed to simplify common array reduction patterns when used with JavaScript's native `Array.prototype.reduce` method. These utilities include functions for tasks such as concatenating nested arrays, performing logical AND/OR operations across array elements, and transforming an array of objects into an indexed object based on a specified attribute. Due to its last update approximately five years ago, the package is considered abandoned, lacks active maintenance, and does not provide native ES module (ESM) support or TypeScript type definitions. It targets older Node.js environments (>=4.0.0), making it less ideal for contemporary JavaScript projects without appropriate transpilation or CJS-to-ESM bridging solutions.

Common errors

```
ReferenceError: require is not defined
```
cause Attempting to use `require()` in an ES module scope (e.g., in a file with `"type": "module"` in `package.json` or a `.mjs` file).

fix Convert your file to a CommonJS module (e.g., use `.js` extension without `"type": "module"`) or use dynamic `import('arrayreduce')` and then access the default export's properties.
```
TypeError: arrayreduce.arrayConcat is not a function
```
cause This error typically occurs if `arrayreduce` was imported using `import arrayreduce from 'arrayreduce';` in an ESM context, which attempts to get a default export that doesn't exist, resulting in `arrayreduce` being `undefined` or an unexpected value.

fix Ensure you are using `const arrayreduce = require('arrayreduce');` for CommonJS imports, or, if in an ESM context, dynamically import it and destructure: `const { arrayConcat } = await import('arrayreduce');`.
```
TS2307: Cannot find module 'arrayreduce' or its corresponding type declarations.
```
cause Using `arrayreduce` in a TypeScript project without type declarations.

fix Create a `d.ts` file (e.g., `arrayreduce.d.ts`) in your project to declare the module and its functions, for example: `declare module 'arrayreduce' { export function arrayConcat(): Function; export function booleanAnd(): Function; export function booleanOr(): Function; export function indexByAttr(key: string): Function; }`

Warnings

breaking This package is considered abandoned, with the last commit dating back approximately five years. There will be no further updates, bug fixes, or security patches. Projects should consider migrating to maintained alternatives or implementing similar utility functions natively.
Fix: Evaluate alternatives like lodash/fp or implement custom reducer functions that suit your project's needs. If continued use is necessary, vendoring the code might be an option, but this is generally not recommended due to security and maintenance overheads.
gotcha The package is a CommonJS (CJS) module and does not natively support ES Modules (ESM) syntax. Direct `import` statements will fail in ESM-only environments or modern Node.js without specific configuration (e.g., Babel, Webpack, or a CJS-ESM bridge).
Fix: Always use `const arrayreduce = require('arrayreduce');` for importing. In modern Node.js ESM projects, you might need to use dynamic `import()` or an ESM wrapper if strict ESM is enforced.
gotcha No TypeScript definitions are shipped with the package, nor are they available on DefinitelyTyped (`@types/arrayreduce`). This means TypeScript projects will infer `any` types for imported functions, losing type safety.
Fix: Create a custom declaration file (e.g., `arrayreduce.d.ts`) to provide type definitions for the functions you use. Alternatively, opt for type-safe alternatives.
gotcha The `package.json` specifies `"node": ">=4.0.0"`. While this doesn't prevent it from running on newer Node.js versions, it indicates the package was developed for and tested against very old environments. It may not leverage modern JavaScript features or best practices.
Fix: No direct fix is required for compatibility, but be aware that the code might not be optimized for current Node.js runtime performance or security features.

Install

npm install arrayreduce npm
yarn add arrayreduce yarn
pnpm add arrayreduce pnpm

Imports

arrayreduce
wrong:
```
import arrayreduce from 'arrayreduce';
```
correct:
```
const arrayreduce = require('arrayreduce');
```
This package is a CommonJS module. Attempting to use default ES module import syntax will likely result in an error or an 'undefined' import without a CJS-ESM compatibility layer.
arrayConcat
wrong:
```
import { arrayConcat } from 'arrayreduce';
```
correct:
```
const { arrayConcat } = require('arrayreduce');
```
Individual utility functions are exported as properties of the main CommonJS module. Direct named ES module imports are not supported.
indexByAttr
wrong:
```
import { indexByAttr } from 'arrayreduce';
```
correct:
```
const { indexByAttr } = require('arrayreduce');
```
Access named exports via object destructuring from the `require()` call, not ES module named imports.

Quickstart

Demonstrates importing the module and using `indexByAttr` to create an object indexed by ID, along with a simple boolean reduction.

const arrayreduce = require('arrayreduce');

// Get a reducer function to index an array of objects by an attribute.
const indexById = arrayreduce.indexByAttr('id');

// Sample data
const data = [
    {id: 101, name: 'Alice', age: 30},
    {id: 102, name: 'Bob', age: 24},
    {id: 103, name: 'Charlie', age: 35}
];

// Execute the reduction to create an indexed object
const indexedResult = data.reduce(indexById, {});

console.log(indexedResult);
/*
Output:
{
  '101': { id: 101, name: 'Alice', age: 30 },
  '102': { id: 102, name: 'Bob', age: 24 },
  '103': { id: 103, name: 'Charlie', age: 35 }
}
*/

// Another example: Boolean AND reduction
const booleanAndReducer = arrayreduce.booleanAnd();
const andResult = [true, false, true].reduce(booleanAndReducer, true);
console.log('Boolean AND result:', andResult); // -> Boolean AND result: false

view raw JSON →