u3 Utility Functions

Common errors

• SyntaxError: Cannot use import statement outside a module

  cause Attempting to use `import` syntax (ES modules) in a project that is configured for CommonJS, or for a CommonJS-only package.
  fix Change your import statement from `import { someFunction } from 'u3';` to `const { someFunction } = require('u3');`. Ensure your `package.json` does not specify `"type": "module"` if you intend to run as CommonJS.

• TypeError: u3.cache is not a function

  cause This error typically occurs when trying to call `u3.cache` or `u3.eachCombination` after `u3` has been imported incorrectly, or if the property is undefined.
  fix Verify that `const u3 = require('u3');` is correctly placed and that you are accessing the functions as properties of the `u3` object (e.g., `u3.cache(...)`) or correctly destructuring `const { cache, eachCombination } = require('u3');`.

Warnings

• breaking This package is strictly CommonJS-only. Attempting to use ES module `import` statements will result in a runtime error in Node.js environments unless configured for ESM compatibility.
  Fix: Use `const u3 = require('u3');` for imports. If using in an ES module environment, consider a CJS-to-ESM wrapper or transpilation.
• gotcha The `cache` function provided only memoizes the *first* result of the function it wraps, or the initial value provided. Subsequent calls, even with different arguments, will return the original cached value without re-execution.
  Fix: Be aware that `cache` does not implement argument-based memoization (like a true `memoize` function). If you need caching specific to argument sets, you'll need a different utility or a custom implementation.
• deprecated The `u3` package appears to be abandoned, with its last known activity and release dating back to 2016. There are no active maintainers, and it is highly unlikely to receive updates, bug fixes, or security patches.
  Fix: For new projects, consider using actively maintained and more robust utility libraries (e.g., Lodash, Underscore.js) or modern native JavaScript features for similar functionalities like memoization (e.g., using `Map` for simple caching) and array iteration.

Install

• npm install u3 npm
• yarn add u3 yarn
• pnpm add u3 pnpm

Imports

• u3
  wrong:

  import u3 from 'u3';

  correct:

  const u3 = require('u3');

  This package is CommonJS-only and does not support ES module `import` syntax.
• cache
  wrong:

  import { cache } from 'u3';

  correct:

  const { cache } = require('u3');

  The `cache` function is a named export available through CommonJS destructuring. Direct ES module imports are not supported.
• eachCombination
  wrong:

  import { eachCombination } from 'u3';

  correct:

  const { eachCombination } = require('u3');

  The `eachCombination` function is a named export available through CommonJS destructuring. Direct ES module imports are not supported.

Quickstart

Demonstrates how to import `u3` using CommonJS `require`, utilize the `cache` function for memoizing both function results and raw values, and iterate through combinations using `eachCombination`.

const u3 = require('u3');

// Use the cache function for memoization
const memoizedSum = u3.cache(function calculateSum(x, y, z) {
    console.log('Calculating sum for:', x, y, z);
    return x + y + z;
});

console.log('Memoized sum (first call):', memoizedSum(1, 2, 3)); // Output: Calculating sum for: 1 2 3, Memoized sum (first call): 6
console.log('Memoized sum (subsequent call, arguments ignored):', memoizedSum(10, 20, 30)); // Output: Memoized sum (subsequent call, arguments ignored): 6

// Cache a simple value directly
const cachedValue = u3.cache(Math.PI * 2);
console.log('Cached value:', cachedValue()); // Output: Cached value: 6.283185307179586

// Use eachCombination to iterate through permutations
console.log('\n--- Combinations ---');
u3.eachCombination([
    [10, 20, 30],
    ['A', 'B']
], function() {
    console.log.apply(console, arguments);
});
/* Expected console output for combinations:
10, A
10, B
20, A
20, B
30, A
30, B
*/