Collection Utilities

1.0.1 · active · verified Sun Apr 19

The `collection-utils` package, at version `1.0.1`, provides a set of fundamental utility functions designed to simplify common operations on JavaScript collections, primarily arrays and objects. Published by `quicktype`, a project focused on generating type bindings from JSON schemas, this library likely serves as an internal dependency or a lightweight, standalone offering for basic collection manipulation. It ships with TypeScript types, facilitating type-safe usage in TypeScript projects. Given its current version, it appears stable but may have a focused, rather than expansive, feature set, with a release cadence potentially tied to the `quicktype` ecosystem's needs. Key differentiators, beyond its small footprint and TypeScript support, are not explicitly detailed in public documentation, suggesting a design for efficiency and straightforward use rather than broad, complex functionality found in larger utility libraries like Lodash.

Common errors

```
TypeError: (0 , collection_utils__WEBPACK_IMPORTED_MODULE_0__.map) is not a function
```
cause This typically indicates that the module was imported incorrectly, or that tree-shaking removed the function because it appeared unused, or a bundler issue.

fix Ensure you are using named imports: `import { map } from 'collection-utils';`. Verify your bundler (e.g., Webpack, Rollup) is configured for ES module resolution and tree-shaking correctly, especially in environments where CommonJS is prevalent.
```
Property 'map' does not exist on type 'typeof import("collection-utils")'.
```
cause This TypeScript error means that the imported `collection-utils` module, when treated as a single object (e.g., `import * as utils from 'collection-utils'; utils.map(...)`), does not expose `map` as a property directly on that root object.

fix Use named imports for individual functions: `import { map } from 'collection-utils';`. The library uses named exports for its utilities.

Warnings

gotcha Many collection utility functions, especially those interacting with objects, might operate on shallow copies or mutate inputs if not explicitly designed for immutability. Always check function documentation or test for mutation if immutability is critical.
Fix: Always assume potential mutation unless documentation states otherwise. For critical state, explicitly create deep copies of objects/arrays before passing them to utility functions using `structuredClone` or a dedicated deep-cloning utility.
gotcha Performance considerations: While convenient, using utility functions on extremely large collections (thousands or millions of items) in tight loops can introduce overhead compared to raw JavaScript loops. Profile your code if performance becomes a bottleneck.
Fix: For performance-critical sections with very large datasets, consider direct `for...of` or `for` loops, or specialized data structures. For most common use cases, the overhead is negligible.
gotcha The library is relatively minimal. Developers coming from larger utility libraries like Lodash or Ramda might expect a broader array of specialized functions (e.g., deep merge, debounce, throttle, advanced string manipulation) which are not present here.
Fix: Review the source code or specific API documentation for available functions. If a required utility is missing, consider importing it from another specialized library or implementing it manually.

Install

npm install collection-utils npm
yarn add collection-utils yarn
pnpm add collection-utils pnpm

Imports

map
wrong:
```
const map = require('collection-utils').map;
```
correct:
```
import { map } from 'collection-utils';
```
This library is primarily designed for ES modules. While CommonJS might technically work, ESM named imports are the canonical and recommended approach for tree-shaking and modern tooling.
filter
wrong:
```
import collectionUtils from 'collection-utils'; collectionUtils.filter(...);
```
correct:
```
import { filter } from 'collection-utils';
```
Functions are exported individually as named exports, promoting modularity and efficient bundling. Avoid attempting to import a default object containing all utilities.
isEmpty
```
import { isEmpty } from 'collection-utils';
```
Common utility functions like `isEmpty` are provided as direct named exports. Ensure your tooling is configured for ES module resolution.

Quickstart

Demonstrates basic usage of `map`, `filter`, and `isEmpty` functions on both arrays and objects, showcasing type-safe operations.

import { map, filter, isEmpty } from 'collection-utils';

interface User { id: number; name: string; isActive: boolean; roles: string[]; }

const users: User[] = [
  { id: 1, name: 'Alice', isActive: true, roles: ['admin', 'editor'] },
  { id: 2, name: 'Bob', isActive: false, roles: ['viewer'] },
  { id: 3, name: 'Charlie', isActive: true, roles: ['editor'] },
  { id: 4, name: 'David', isActive: false, roles: [] }
];

// Use 'map' to transform a collection
const userNames = map(users, user => user.name);
console.log('User Names:', userNames); // Expected: ['Alice', 'Bob', 'Charlie', 'David']

// Use 'filter' to select elements based on a condition
const activeEditors = filter(users, user => user.isActive && user.roles.includes('editor'));
console.log('Active Editors:', activeEditors.map(u => u.name)); // Expected: ['Alice', 'Charlie']

// Use 'isEmpty' to check if a collection is empty
const hasActiveUsers = !isEmpty(filter(users, user => user.isActive));
console.log('Are there any active users?', hasActiveUsers); // Expected: true

const emptyArray: any[] = [];
console.log('Is emptyArray empty?', isEmpty(emptyArray)); // Expected: true

const emptyObject = {};
console.log('Is emptyObject empty?', isEmpty(emptyObject)); // Expected: true

view raw JSON →