is-what-type

A simple utility library for type checking.

Installation

npm

npm add is-what-type

pnpm

pnpm add is-what-type

yarn

yarn add is-what-type

bun

bun add is-what-type

Features

• 📋 API Count: Provides 15 practical type detection functions.
• ⚡ Efficient & Accurate: Efficient type detection functions with guaranteed accuracy.
• 📖 Easy to Use: Simple and intuitive API design for quick onboarding.
• 📦 Compatibility: Works in both JavaScript and TypeScript environments.
• ✅ Unit Test Coverage: All features are fully covered by unit tests.
• 🔗 Zero Dependencies: No third-party dependencies for lightweight usage.

API List

getType

Get the type of a value.

import { getType } from 'is-what-type';

console.log(getType(null)); // 'Null'
console.log(getType(undefined)); // 'Undefined'
console.log(getType(1)); // 'Number'
console.log(getType('string')); // 'String'
console.log(getType(true)); // 'Boolean'
console.log(getType([])); // 'Array'
console.log(getType({})); // 'Object'
console.log(getType(function() {})); // 'Function'
console.log(getType(new Date())); // 'Date'
console.log(getType(new RegExp(''))); // 'RegExp'
console.log(getType(new Error())); // 'Error'
console.log(getType(new Map())); // 'Map'
console.log(getType(new Set())); // 'Set'
console.log(getType(new WeakMap())); // 'WeakMap'
console.log(getType(new WeakSet())); // 'WeakSet'
console.log(getType(new Promise(() => {}))); // 'Promise'
console.log(getType(Symbol())); // 'Symbol'
console.log(getType(new Int8Array())); // 'Int8Array'
// ... (other TypedArray examples)

isAbsoluteURL

Check if a value is an absolute URL.

import { isAbsoluteURL } from 'is-what-type';

console.log(isAbsoluteURL('https://github.com')); // true
console.log(isAbsoluteURL('/src/index.js')); // false
console.log(isAbsoluteURL('http://example.com')); // true
console.log(isAbsoluteURL('example.com')); // false

isArrayLike

Check if a value is an array-like object.

import { isArrayLike } from 'is-what-type';

console.log(isArrayLike('123')); // true
console.log(isArrayLike(() => {})); // false
console.log(isArrayLike([])); // true
console.log(isArrayLike([1, 2, 3])); // true
console.log(isArrayLike({ 0: 1, length: 1 })); // true

isAsyncFunction

Check if a value is an async function.

import { isAsyncFunction } from 'is-what-type';

async function asyncFunction() {}

console.log(isAsyncFunction(asyncFunction)); // true
console.log(isAsyncFunction(() => {})); // false
console.log(isAsyncFunction(function() {})); // false
console.log(isAsyncFunction({})); // false

isESModule

Check if a value is an ES module.

import { isESModule } from 'is-what-type';

const esModule = { __esModule: true };
const generatorFunction = function*() {};
const generatorObject = generatorFunction();

console.log(isESModule(esModule)); // true
console.log(isESModule(generatorFunction)); // false
console.log(isESModule(generatorObject)); // false
console.log(isESModule({})); // false

isFunction

Check if a value is a function.

import { isFunction } from 'is-what-type';

isFunction(async () => { }); // true
isFunction(() => { }); // true
isFunction(123); // false
isFunction('string'); // false
isFunction({}); // false

isError

Check if a value is an error object.

import { isError } from 'is-what-type';

console.log(isError(new Error('error'))); // true
console.log(isError({ name: 'Error' })); // true
console.log(isError('error')); // false
console.log(isError({})); // false

isIterable

Check if a value is an iterable object.

import { isIterable } from 'is-what-type';

console.log(isIterable([])); // true
console.log(isIterable('string')); // true
console.log(isIterable(new Map())); // true
console.log(isIterable({})); // false
console.log(isIterable(null)); // false
console.log(isIterable(undefined)); // false

isLeapYear

Check if a year is a leap year.

import { isLeapYear } from 'is-what-type';

console.log(isLeapYear(2000)); // true
console.log(isLeapYear(2004)); // true
console.log(isLeapYear(1900)); // false
console.log(isLeapYear(2021)); // false

isLength

Check if a value is a valid array-like length.

import { isLength } from 'is-what-type';

console.log(isLength(3)); // true
console.log(isLength(Number.MIN_VALUE)); // false
console.log(isLength(Infinity)); // false
console.log(isLength('3')); // false

isNil

Check if a value is null or undefined.

import { isNil } from 'is-what-type';

console.log(isNil(null)); // true
console.log(isNil(undefined)); // true
console.log(isNil({})); // false

isNumber

Check if a value is a number.

import { isNumber } from 'is-what-type';

console.log(isNumber(1)); // true
console.log(isNumber(NaN)); // false
console.log(isNumber('1')); // false

isObject

Check if a value is an object.

import { isObject } from 'is-what-type';

console.log(isObject({})); // true
console.log(isObject([])); // true
console.log(isObject(null)); // false
console.log(isObject(1)); // false

isPlainObject

Check if a value is a plain object.

import { isPlainObject } from 'is-what-type';

console.log(isPlainObject({})); // true
console.log(isPlainObject(new Date())); // false
console.log(isPlainObject([])); // false
console.log(isPlainObject(null)); // false
console.log(isPlainObject(undefined)); // false

isPromiseLike

Check if a value is a promise-like object.

import { isPromiseLike } from 'is-what-type';

console.log(isPromiseLike(new Promise(() => {}))); // true
console.log(isPromiseLike({ then: () => {} })); // true
console.log(isPromiseLike({ then: 'not a function' })); // false
console.log(isPromiseLike({})); // false

isValidDate

Check if a value is a valid date.

import { isValidDate } from 'is-what-type';

console.log(isValidDate(new Date())); // true
console.log(isValidDate(new Date('invalid'))); // false
console.log(isValidDate('2023-10-01')); // false