over - Function Overloading

Common errors

• ReferenceError: require is not defined

  cause Attempting to use `require()` in an ES Module context (e.g., in a `.mjs` file or a `.js` file where `"type": "module"` is set in `package.json`).
  fix Change your module to CommonJS by ensuring it's a `.js` file and not declared as an ES Module in `package.json`, or use a dynamic `import()` if absolutely necessary: `const over = await import('over');`.

• TypeError: over is not a function

  cause Incorrectly attempting to use named imports or default ES Module imports (`import over from 'over';`) in an environment where `over` only provides a CommonJS export.
  fix Ensure you are using the correct CommonJS `require` syntax for importing the package: `const over = require('over');`.

Warnings

• breaking This package appears to be abandoned since 2013 and is no longer maintained. Using an unmaintained library introduces significant security risks, as it will not receive patches for vulnerabilities or updates for compatibility with modern JavaScript runtimes or security standards.
  Fix: Evaluate modern alternatives for function overloading or implement pattern matching manually using contemporary JavaScript features. Consider using TypeScript's built-in overloading capabilities for type-safe overloading.
• gotcha The package was developed for CommonJS environments and does not natively support ES Modules (ESM). Attempting to `import over from 'over';` in an ESM context will likely result in errors like `ERR_REQUIRE_ESM` or `over is not defined`.
  Fix: If you must use this package in an ESM project, consider dynamic `import()` or wrapper CJS modules, but prefer refactoring to avoid this dependency in modern applications.
• gotcha Due to its age, `over` may exhibit compatibility issues with newer Node.js versions, particularly those released after 2013. Behavior might be undefined or lead to runtime errors, especially with changes in core APIs or internal JavaScript engine optimizations.
  Fix: Thoroughly test the package in your specific Node.js environment. Consider containerizing applications to pin Node.js versions if legacy dependencies are unavoidable, but a full refactor is recommended.

Install

• npm install over npm
• yarn add over yarn
• pnpm add over pnpm

Imports

• over
  wrong:

  import over from 'over';

  correct:

  const over = require('over');

  This package primarily supports CommonJS due to its age (last updated ~2013). Direct ES Module (ESM) import is not supported.
• over.string
  wrong:

  import { string } from 'over';

  correct:

  const over = require('over');
  const myFn = over([over.string, function (str) { /* ... */ }]);

  Built-in test functions like `over.string` are properties of the default `over` export (a function) and are not individually named exports.

Quickstart

Demonstrates defining multiple function overloads using `over` with various argument matchers, including optional parameters with defaults and callbacks, then calling the overloaded function with different argument sets to show matching behavior.

const over = require('over');

const myfn = over([
  [over.string, function (str) { console.log('Called with a single string:', str); }],
  [over.string, over.numberOptionalWithDefault(5), over.callbackOptional, function (str, number, callback) {
    console.log('Called with string, optional number (default 5), and optional callback.');
    console.log('String:', str, 'Number:', number);
    if (callback) {
      console.log('Executing callback...');
      callback(str, number);
    }
  }],
  function() {
    console.log('No specific overload matched. Falling back to default.');
  }
]);

// Test cases
myfn("hello");
myfn("world", 10, (s, n) => console.log(`Callback invoked: ${s}, ${n}`));
myfn("test", null, (s, n) => console.log(`Callback invoked with null number: ${s}, ${n}`)); // numberOptionalWithDefault should handle null/undefined
myfn("another test", undefined, (s, n) => console.log(`Callback invoked with undefined number: ${s}, ${n}`));
myfn(); // Should hit default