is-type-of: Complete Type Checking for Node.js

Common errors

• TypeError: is_type_of_1.isArray is not a function

  cause Attempting to access a named export like `isArray` on the default imported `is` object, often due to incorrect import syntax when using ESM or TypeScript's default transpilation.
  fix If importing the main `is` object, access the method as `is.isArray(value)`. If you want `isArray` as a direct function, use named import: `import { isArray } from 'is-type-of';`.

• TypeError: Cannot read properties of undefined (reading 'array') (or similar for other methods)

  cause The default `is` object was not correctly imported, resulting in `is` being `undefined` or not having the expected properties.
  fix Ensure `import is from 'is-type-of';` (for ESM/TypeScript) or `const is = require('is-type-of');` (for CommonJS) is used to correctly import the main utility object.

• ERR_REQUIRE_ESM

  cause Attempting to `require()` an ES Module in a CommonJS context, or subtle module resolution issues when a project mixes ESM and CJS.
  fix Since v2.1.0, `is-type-of` is built with `tshy` for dual ESM/CJS support. Ensure your Node.js version is recent enough to handle dual packages correctly (Node.js 12+ usually suffices, but Node.js 14+ is recommended for full feature set). If possible, refactor your consuming code to use `import` syntax if your project is ESM-first, or ensure your bundler/loader is correctly configured for dual-package consumption.

Warnings

• gotcha The `is.array()` and `isArray()` functions only check if the value itself is an array, not the types of its elements. Developers expecting deep array type validation will need additional logic.
  Fix: Manually iterate through array elements and apply `is.typeOf()` checks or use a third-party deep validation library if element-level validation is required.
• gotcha The library explicitly differentiates between primitive types (e.g., `string`, `number`, `boolean`) and their corresponding object wrappers (`String`, `Number`, `Boolean`). Functions like `is.string()` will return `false` for `new String('value')`.
  Fix: Always use primitive literals for values expected to be primitive types. If object wrappers might be encountered, convert them to primitives (`String(value)`) or check for both (`is.string(val) || is.object(val) && val instanceof String`).
• gotcha While `is-type-of` supports both ES Modules (ESM) and CommonJS (CJS) since v2.1.0, incorrect import syntax can still lead to runtime errors, particularly when mixing module styles or when TypeScript's `esModuleInterop` is not configured correctly. The package's CommonJS export structure is primarily a default export containing all methods.
  Fix: For ESM, use `import is from 'is-type-of'` for the main object and `import { isArray } from 'is-type-of'` for individual helpers. For CJS, use `const is = require('is-type-of')` and access methods via `is.isArray`. Ensure `"esModuleInterop": true` in `tsconfig.json` for TypeScript projects consuming CJS packages that export a default.

Install

• npm install is-type-of npm
• yarn add is-type-of yarn
• pnpm add is-type-of pnpm

Imports

• is
  wrong:

  import { is } from 'is-type-of';

  correct:

  import is from 'is-type-of';

  The primary `is` object is exported as a default. Use default import for the main utility object.
• isArray
  wrong:

  import isArray from 'is-type-of';

  correct:

  import { isArray } from 'is-type-of';

  Individual type checking functions (e.g., `isArray`, `isString`) are named exports. Do not use default import for these.
• is
  wrong:

  const { isArray } = require('is-type-of');

  correct:

  const is = require('is-type-of');

  Since v2.1.0, the package supports both ESM and CommonJS. For CommonJS, `require('is-type-of')` returns the main `is` object, which contains all type-checking methods as properties (e.g., `is.isArray`). Direct destructuring of named exports via `require` is not the intended pattern; use `is.isArray` instead.
• BigInt

  import type { BigInt } from 'is-type-of';

  For TypeScript users, type definitions are included. Specific types for type guards are inferred or can be imported if needed for advanced scenarios, though direct type imports like `BigInt` are less common for a utility focused on runtime checks.

Quickstart

Demonstrates both default and named imports for various type checks, including basic primitives, objects, generator functions, and BigInt. It also illustrates the usage of TypeScript type guards provided by the library.

import is, { isArray, isString } from 'is-type-of';

console.log('--- Using default import (is.method) ---');
console.log('Is [] an array?', is.array([]));
console.log('Is 123 a number?', is.number(123));
console.log('Is "hello" a string?', is.string('hello'));
console.log('Is {} an object?', is.object({}));
console.log('Is function*() {} a generator function?', is.generatorFunction(function* () {}));

console.log('\n--- Using named imports (isMethod) ---');
console.log('Is [] an array (named)?', isArray([]));
console.log('Is "world" a string (named)?', isString('world'));

function processData(data: string[] | string) {
  // TypeScript type guard example
  if (isArray(data)) {
    console.log(`\nProcessing array of length: ${data.length}`);
    data.forEach(item => console.log(`  - Array item: ${item}`));
  } else {
    console.log(`\nProcessing string: ${data}`);
  }
}

processData(['apple', 'banana']);
processData('orange');

// Example with a less common type check
const bigIntValue = BigInt(9007199254740991);
console.log(`\nIs ${bigIntValue} a BigInt?`, is.bigInt(bigIntValue));