Registry / serialization / type

type

JSON →
library2.7.3jsnpmunverified

The `type` package offers a suite of runtime validation and processing utilities for fundamental JavaScript types, engineered for environments supporting ECMAScript 3 and higher without implying any transpilation. It specializes in bulletproof input argument normalization and validation, making it highly suitable for validating public API endpoints. The library's current stable version is 2.7.3, released in May 2024, and it follows an irregular release cadence, focusing on maintenance improvements and incremental feature additions like `BigInt` or `Map`/`Set` validation. Its core differentiators include a deep respect for JavaScript's inherent language nature and quirks, offering restricted forms of type coercion that explicitly reject invalid input while intelligently normalizing permissible type deviations. It provides `coerce`, `is`, and `ensure` utilities for various types, enabling developers to confirm types, safely coerce values, or strictly validate them with configurable error handling, including options for optional values and default fallbacks. It's explicitly positioned for basic type checks, recommending more powerful schema-based utilities like AJV or Joi for complex, deeply nested object structures.

serialization
npm install type
github ↗package ↗
INSTALL
IMPORT
SIG · TYPE
T
type
serializationjavascriptv2.7.3
Install
—
Import
—
Disk
—
Pass rate
0/ 6
Env Coverage0 / 6
glibc
18–22
musl
18–22
Install & Compatibility
Where this runs
tested against v? · npm install
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
musl
node 18–226 runs
build_error
glibc
node 18–226 runs
build_error
Code
Verified usage

Verified import paths — ran on the pinned version, not inferred.

ensureString
✓ const ensureString = require('type/string/ensure');
✗ import { ensureString } from 'type/string/ensure';
This package primarily utilizes CommonJS `require()` for accessing its modular sub-path utilities, as demonstrated in its examples.
isObject
✓ const isObject = require('type/object/is');
✗ import { isObject } from 'type/object/is';
CommonJS `require()` is the intended method for importing specific type checking utilities.
ensureNaturalNumber
✓ const ensureNaturalNumber = require('type/natural-number/ensure');
✗ import { ensureNaturalNumber } from 'type/natural-number/ensure';
Each type utility is exposed via a dedicated CommonJS sub-path.

This example demonstrates how to normalize and validate function arguments using various `type` utilities, including string, date, natural number, and object checks, applying options like error messages, optionality, and default values for robust input handling.

const ensureString = require('type/string/ensure'); const ensureDate = require('type/date/ensure'); const ensureNaturalNumber = require('type/natural-number/ensure'); const isObject = require('type/object/is'); function processData(path, options = { min: 0 }) { path = ensureString(path, { errorMessage: "%v is not a valid path string" }); if (!isObject(options)) { console.warn("Options provided were not an object, defaulting to empty."); options = {}; } const min = ensureNaturalNumber(options.min, { default: 0 }); const max = ensureNaturalNumber(options.max, { isOptional: true, errorMessage: "Max value '%v' is not a natural number" }); const startTime = ensureDate(options.startTime, { isOptional: true }); console.log(`Processing path: ${path}`); console.log(`Min: ${min}, Max: ${max === null ? 'N/A' : max}`); console.log(`Start Time: ${startTime === null ? 'N/A' : startTime.toISOString()}`); // ...further logic based on validated inputs } // Example usage: processData('/api/resource', { min: 5, max: 10, startTime: new Date() }); processData('/another/path', { min: 'abc' }); // Will throw TypeError for min processData('/default/options');
Debug
Known issues
gotchaThe `type` package is designed for validating and coercing primitive or simple JavaScript types. For complex, deeply nested object structures or schema-based validation, it's explicitly recommended to use more powerful dedicated schema utilities like AJV or Hapi/Joi, as `type` does not offer this functionality.
fix
For complex object validation, integrate a schema validation library like AJV or Hapi/Joi instead of trying to compose complex validations with `type` utilities.
affects: >=2.0.0
gotchaThe library explicitly states 'No transpilation implied', meaning users should not expect it to polyfill modern JavaScript features. It's written to work in ECMAScript 3+ engines, focusing purely on type validation.
fix
Ensure your target environment natively supports the JavaScript features you are using, or implement your own transpilation/polyfill solution if needed. Do not rely on this library for environment compatibility.
affects: >=2.0.0
gotchaBy default, `*/ensure` utilities throw a `TypeError` if the input value does not meet the specified constraints. This requires explicit error handling (e.g., `try...catch`) or the use of `isOptional` and `default` options to prevent exceptions.
fix
Wrap calls to `*/ensure` in `try...catch` blocks to gracefully handle validation failures, or configure the `isOptional: true` option to accept `null`/`undefined` and `default` option to provide a fallback value.
affects: >=2.0.0
gotchaThe `*/coerce` utilities offer 'restricted coercion' and return `null` if a value is not coercible according to their rules, rather than throwing an error. This differs from the error-throwing behavior of `*/ensure`.
fix
When using `*/coerce`, always check for `null` in the returned value to determine if coercion was successful. Do not assume a non-null return value without checking.
affects: >=2.0.0
Errors
Common errors & fixes
TypeError: Invalid [type] provided for [name] ([value])
An input value failed validation when passed to an `*/ensure` utility without `isOptional` or `default` options.
fix
Provide a value that satisfies the type constraints of the `*/ensure` utility, or configure the `isOptional: true` option to allow `null`/`undefined`, or set a `default` value.
ReferenceError: require is not defined
Attempting to use `require()` statements (CommonJS) in an environment or file configured for ECMAScript Modules (ESM) without proper interoperability setup.
fix
Ensure your project is configured for CommonJS (e.g., by omitting `"type": "module"` in `package.json` or by using `.cjs` file extensions for CommonJS files), or use a build tool like Webpack or Rollup to bundle CommonJS modules for an ESM target.
Upgrade
Version history
2.7.3latest on npm
Audit
Dependencies

No dependency data recorded yet.

Agent activity
11 hits · last 30 days
node
10
OpenAI (training)
1
Resources
githubhttps://github.com/medikoo/type ↗
packagehttps://www.npmjs.com/package/type ↗
type — npm install type · libregistry