Mnemonist Data Structures Library

Common errors

• TypeError: (0 , mnemonist_1.Set) is not a function

  cause Attempting to use the `Set` operations module with the uppercase 'Set' path after v0.40.0, where it was renamed to lowercase 'set'.
  fix Update your import statement for Set operations from `import { operation } from 'mnemonist/Set';` to `import { operation } from 'mnemonist/set';`

• TypeError: __webpack_require__(...).Heap is not a constructor

  cause This error, common in bundled environments, indicates an incorrect import or module resolution, often when using `require()` syntax in an ESM context or an incorrect named import path.
  fix Ensure you are using specific, correct import paths like `import { Heap } from 'mnemonist/heap';`. If using CommonJS, `const Heap = require('mnemonist/heap');`. Verify your bundler configuration for proper module resolution, especially if on versions prior to 0.40.0.

Warnings

• breaking The module for generic Set operations (e.g., `intersection`, `union`) was renamed from `Set` to `set` (lowercase) in v0.40.0. This was done to resolve a CommonJS named export collision. Users should update their import paths.
  Fix: Change `import { operation } from 'mnemonist/Set';` to `import { operation } from 'mnemonist/set';`
• gotcha Prior to v0.40.0, Mnemonist primarily supported CommonJS modules. While browser bundling was possible, direct ESM named exports were not officially supported. Version 0.40.0 introduced comprehensive ESM named exports, improving compatibility with modern build tools and environments.
  Fix: For optimal ESM compatibility, upgrade to v0.40.0 or higher. For older versions, rely on CommonJS `require()` or ensure your bundler correctly handles the CJS output.
• gotcha Several type declaration fixes for specific data structures (e.g., `BloomFilter.from`, `SparseMap` constructor overloads, `BiMap.get`) were released in recent minor versions. Users relying heavily on TypeScript might encounter type-related issues or missing overloads if they are not on the latest minor release for their major version.
  Fix: Ensure you are using the latest patch version (e.g., `0.40.3`) to benefit from the most up-to-date and accurate TypeScript declarations.

Install

• npm install mnemonist npm
• yarn add mnemonist yarn
• pnpm add mnemonist pnpm

Imports

• Heap
  wrong:

  const Heap = require('mnemonist/heap');

  correct:

  import { Heap } from 'mnemonist/heap';

  For modularity, most data structures are imported directly from their respective paths. CommonJS 'require' syntax also follows this pattern.
• BloomFilter
  wrong:

  import { BloomFilter } from 'mnemonist';

  correct:

  import { BloomFilter } from 'mnemonist/bloom-filter';

  Individual data structures are typically imported from their specific module path, not directly from the main 'mnemonist' package name. This ensures tree-shaking and modularity.
• set
  wrong:

  import { intersection } from 'mnemonist/Set';

  correct:

  import { intersection } from 'mnemonist/set';

  Since v0.40.0, the module for set operations was renamed from `Set` to `set` (lowercase) to avoid CommonJS named export collisions. TypeScript users should also update their imports accordingly.

Quickstart

This quickstart demonstrates the instantiation and basic usage of a Min-Heap, a Bloom Filter, a BiMap, and a set intersection operation, showcasing common patterns for importing and interacting with Mnemonist data structures.

import { Heap } from 'mnemonist/heap';
import { BloomFilter } from 'mnemonist/bloom-filter';
import { BiMap } from 'mnemonist/bi-map';
import { intersection } from 'mnemonist/set'; // Note: 'set' module name for operations since v0.40.0

console.log('--- Using a Min-Heap ---');
const minHeap = new Heap<number>((a, b) => a - b); // Custom comparator for min-heap
minHeap.push(5);
minHeap.push(2);
minHeap.push(8);
console.log('Heap size:', minHeap.size); // Expected: 3
console.log('Min element:', minHeap.pop()); // Expected: 2
console.log('Min element after pop:', minHeap.pop()); // Expected: 5

console.log('\n--- Using a Bloom Filter ---');
const filter = new BloomFilter(100, 3); // 100 bits, 3 hash functions
filter.add('apple');
filter.add('banana');
console.log('Contains "apple":', filter.has('apple')); // Expected: true
console.log('Contains "orange":', filter.has('orange')); // Expected: false (or very likely false)

console.log('\n--- Using a BiMap ---');
const biMap = new BiMap<string, number>();
biMap.set('one', 1);
biMap.set('two', 2);
console.log('Value for "one":', biMap.get('one')); // Expected: 1
console.log('Key for 2 via inverse map:', biMap.inverse.get(2)); // Expected: "two"
console.log('Has "three":', biMap.has('three')); // Expected: false

console.log('\n--- Using Set Operations ---');
const setA = new Set([1, 2, 3]);
const setB = new Set([2, 3, 4]);
const commonElements = intersection(setA, setB);
console.log('Intersection of {1,2,3} and {2,3,4}:', Array.from(commonElements)); // Expected: [2, 3]