Typpy: Enhanced Type Checking

Common errors

• TypeError: Typpy.is is not a function

  cause Attempting to import `is` as a named export (`import { is } from 'typpy';`) instead of accessing it as a property of the default export.
  fix Change your import statement to `import Typpy from 'typpy';` and then call `Typpy.is(value, type);`.

• ReferenceError: require is not defined

  cause Using `const Typpy = require('typpy');` in an environment configured for ECMAScript Modules (ESM) without a CommonJS shim.
  fix Update your import statement to use ESM syntax: `import Typpy from 'typpy';`.

• Typpy is not defined

  cause The Typpy package was not correctly installed or imported. This could be due to a typo in the import path or a missing `npm install typpy` step.
  fix First, ensure the package is installed: `npm install typpy`. Then, verify the import statement `import Typpy from 'typpy';` (for ESM) or `const Typpy = require('typpy');` (for CommonJS) is correct and at the top of your file.

Warnings

• gotcha The documentation primarily showcases CommonJS `require` syntax. While modern Node.js and bundlers support `import Typpy from 'typpy';` for ESM, direct named exports like `import { is } from 'typpy';` are not provided. Always import the default `Typpy` object and access `is` and `get` as properties.
  Fix: Use `import Typpy from 'typpy';` and then `Typpy.is(...)` or `Typpy.get(...)` for ESM. For CommonJS, `const Typpy = require('typpy');` remains valid.
• gotcha Typpy's primary function `Typpy(input, target)` returns a boolean if `target` is provided, but a string if `target` is omitted. Ensure you handle both return types correctly in your logic.
  Fix: When using `Typpy(input, target)`, check for a boolean result. When using `Typpy(input)` to get the type, expect a string. If consistent boolean results are desired, prefer `Typpy.is(input, target)`.
• gotcha Unlike the native `typeof` operator which returns 'object' for `null`, `Typpy.is(null, 'null')` correctly evaluates to `true`. Be aware of this difference when migrating code or expecting native `typeof` behavior.
  Fix: Leverage `Typpy`'s accurate `null` checking. If you specifically need the native `typeof` behavior, use the built-in operator directly. For consistent and precise type checking across all primitive and object types, stick with `Typpy`.

Install

• npm install typpy npm
• yarn add typpy yarn
• pnpm add typpy pnpm

Imports

• Typpy
  wrong:

  const Typpy = require('typpy');

  correct:

  import Typpy from 'typpy';

  For ESM, use default import. The package's primary export is a callable function that also carries `is` and `get` methods as properties. CommonJS `require` is still widely used in older Node.js projects, but `import` is preferred for modern JavaScript.
• Typpy.is
  wrong:

  import { is } from 'typpy';

  correct:

  import Typpy from 'typpy'; Typpy.is(value, type);

  The `is` method is a property of the default `Typpy` export, not a standalone named export. It's accessed directly via the imported `Typpy` object/function.
• Typpy.get
  wrong:

  import { get } from 'typpy';

  correct:

  import Typpy from 'typpy'; Typpy.get(value);

  Similar to `Typpy.is`, the `get` method is a property of the default `Typpy` export, not a named export. Access it via `Typpy.get` after importing the default.

Quickstart

This example demonstrates how to use the main `Typpy` function to get a type string or compare against a target, and how to use the `Typpy.is` and `Typpy.get` helper methods for specific type checks.

import Typpy from 'typpy';

console.log(Typpy(0));
// => "number"

console.log(Typpy('', String));
// => true

console.log(Typpy.is(null, 'null'));
// => true

console.log(Typpy.get([]));
// => Array

console.log(Typpy({}, true));
// => false

console.log(Typpy({}, Object));
// => true

console.log(Typpy.get({}));
// => Object

console.log(Typpy.get(42, true));
// => "number"