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
github ↗package ↗
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.

This package primarily utilizes CommonJS `require()` for accessing its modular sub-path utilities, as demonstrated in its examples.

const ensureString = require('type/string/ensure');

CommonJS `require()` is the intended method for importing specific type checking utilities.

const isObject = require('type/object/is');

Each type utility is exposed via a dedicated CommonJS sub-path.

const ensureNaturalNumber = require('type/natural-number/ensure');

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 footguns
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.
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.
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.
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`.
Upgrade
Version history

Breaking-change detection hasn't run for this library yet.

Audit
Security & dependencies

CVE tracking and dependency tree are planned for a later release.

Agent activity
10 hits · last 30 days
gptbot
4
ahrefsbot
3
script
1
mj12bot
1
Resources
githubhttps://github.com/medikoo/type ↗
packagehttps://www.npmjs.com/package/type ↗