@sindresorhus/is

  • Version 5.3.0
  • Published
  • 58.9 kB
  • No dependencies
  • MIT license

Install

npm i @sindresorhus/is
yarn add @sindresorhus/is
pnpm add @sindresorhus/is

Overview

Type check values

Index

Variables

Functions

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable assert

const assert: Assert;

    variable objectTypeNames

    const objectTypeNames: readonly [
    'Function',
    'Generator',
    'AsyncGenerator',
    'GeneratorFunction',
    'AsyncGeneratorFunction',
    'AsyncFunction',
    'Observable',
    'Array',
    'Buffer',
    'Blob',
    'Object',
    'RegExp',
    'Date',
    'Error',
    'Map',
    'Set',
    'WeakMap',
    'WeakSet',
    'WeakRef',
    'ArrayBuffer',
    'SharedArrayBuffer',
    'DataView',
    'Promise',
    'URL',
    'FormData',
    'URLSearchParams',
    'HTMLElement',
    'NaN',
    'Int8Array',
    'Uint8Array',
    'Uint8ClampedArray',
    'Int16Array',
    'Uint16Array',
    'Int32Array',
    'Uint32Array',
    'Float32Array',
    'Float64Array',
    'BigInt64Array',
    'BigUint64Array'
    ];

      variable primitiveTypeNames

      const primitiveTypeNames: readonly [
      'null',
      'undefined',
      'string',
      'number',
      'bigint',
      'boolean',
      'symbol'
      ];

        Functions

        function is

        is: typeof is;

          Interfaces

          interface ArrayLike

          interface ArrayLike<T> {}

            property length

            readonly length: number;

              index signature

              readonly [index: number]: T;

                interface NodeStream

                interface NodeStream extends NodeJS.EventEmitter {}

                  method pipe

                  pipe: <T extends NodeJS.WritableStream>(
                  destination: T,
                  options?: { end?: boolean }
                  ) => T;

                    interface ObservableLike

                    interface ObservableLike {}
                    • Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).

                    method [Symbol.observable]

                    [Symbol.observable]: () => ObservableLike;

                      method subscribe

                      subscribe: (observer: (value: unknown) => void) => void;

                        Enums

                        enum AssertionTypeDescription

                        const enum AssertionTypeDescription {
                        class_ = 'Class',
                        numericString = 'string with a number',
                        nullOrUndefined = 'null or undefined',
                        iterable = 'Iterable',
                        asyncIterable = 'AsyncIterable',
                        nativePromise = 'native Promise',
                        urlString = 'string with a URL',
                        truthy = 'truthy',
                        falsy = 'falsy',
                        nan = 'NaN',
                        primitive = 'primitive',
                        integer = 'integer',
                        safeInteger = 'integer',
                        plainObject = 'plain object',
                        arrayLike = 'array-like',
                        typedArray = 'TypedArray',
                        domElement = 'HTMLElement',
                        nodeStream = 'Node.js Stream',
                        infinite = 'infinite number',
                        emptyArray = 'empty array',
                        nonEmptyArray = 'non-empty array',
                        emptyString = 'empty string',
                        emptyStringOrWhitespace = 'empty string or whitespace',
                        nonEmptyString = 'non-empty string',
                        nonEmptyStringAndNotWhitespace = 'non-empty string and not whitespace',
                        emptyObject = 'empty object',
                        nonEmptyObject = 'non-empty object',
                        emptySet = 'empty set',
                        nonEmptySet = 'non-empty set',
                        emptyMap = 'empty map',
                        nonEmptyMap = 'non-empty map',
                        evenInteger = 'even integer',
                        oddInteger = 'odd integer',
                        directInstanceOf = 'T',
                        inRange = 'in range',
                        any = 'predicate returns truthy for any value',
                        all = 'predicate returns truthy for all values',
                        }

                          member all

                          all = 'predicate returns truthy for all values'

                            member any

                            any = 'predicate returns truthy for any value'

                              member arrayLike

                              arrayLike = 'array-like'

                                member asyncIterable

                                asyncIterable = 'AsyncIterable'

                                  member class_

                                  class_ = 'Class'

                                    member directInstanceOf

                                    directInstanceOf = 'T'

                                      member domElement

                                      domElement = 'HTMLElement'

                                        member emptyArray

                                        emptyArray = 'empty array'

                                          member emptyMap

                                          emptyMap = 'empty map'

                                            member emptyObject

                                            emptyObject = 'empty object'

                                              member emptySet

                                              emptySet = 'empty set'

                                                member emptyString

                                                emptyString = 'empty string'

                                                  member emptyStringOrWhitespace

                                                  emptyStringOrWhitespace = 'empty string or whitespace'

                                                    member evenInteger

                                                    evenInteger = 'even integer'

                                                      member falsy

                                                      falsy = 'falsy'

                                                        member infinite

                                                        infinite = 'infinite number'

                                                          member inRange

                                                          inRange = 'in range'

                                                            member integer

                                                            integer = 'integer'

                                                              member iterable

                                                              iterable = 'Iterable'

                                                                member nan

                                                                nan = 'NaN'

                                                                  member nativePromise

                                                                  nativePromise = 'native Promise'

                                                                    member nodeStream

                                                                    nodeStream = 'Node.js Stream'

                                                                      member nonEmptyArray

                                                                      nonEmptyArray = 'non-empty array'

                                                                        member nonEmptyMap

                                                                        nonEmptyMap = 'non-empty map'

                                                                          member nonEmptyObject

                                                                          nonEmptyObject = 'non-empty object'

                                                                            member nonEmptySet

                                                                            nonEmptySet = 'non-empty set'

                                                                              member nonEmptyString

                                                                              nonEmptyString = 'non-empty string'

                                                                                member nonEmptyStringAndNotWhitespace

                                                                                nonEmptyStringAndNotWhitespace = 'non-empty string and not whitespace'

                                                                                  member nullOrUndefined

                                                                                  nullOrUndefined = 'null or undefined'

                                                                                    member numericString

                                                                                    numericString = 'string with a number'

                                                                                      member oddInteger

                                                                                      oddInteger = 'odd integer'

                                                                                        member plainObject

                                                                                        plainObject = 'plain object'

                                                                                          member primitive

                                                                                          primitive = 'primitive'

                                                                                            member safeInteger

                                                                                            safeInteger = 'integer'

                                                                                              member truthy

                                                                                              truthy = 'truthy'

                                                                                                member typedArray

                                                                                                typedArray = 'TypedArray'

                                                                                                  member urlString

                                                                                                  urlString = 'string with a URL'

                                                                                                    Type Aliases

                                                                                                    type Class

                                                                                                    type Class<T = unknown, Arguments extends any[] = any[]> = new (
                                                                                                    ...arguments_: Arguments
                                                                                                    ) => T;
                                                                                                    • Matches a [class constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).

                                                                                                    type Predicate

                                                                                                    type Predicate = (value: unknown) => boolean;

                                                                                                      type Primitive

                                                                                                      type Primitive = null | undefined | string | number | boolean | symbol | bigint;
                                                                                                      • Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).

                                                                                                      type TypedArray

                                                                                                      type TypedArray =
                                                                                                      | Int8Array
                                                                                                      | Uint8Array
                                                                                                      | Uint8ClampedArray
                                                                                                      | Int16Array
                                                                                                      | Uint16Array
                                                                                                      | Int32Array
                                                                                                      | Uint32Array
                                                                                                      | Float32Array
                                                                                                      | Float64Array
                                                                                                      | BigInt64Array
                                                                                                      | BigUint64Array;
                                                                                                      • Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like Uint8Array or Float64Array.

                                                                                                      type TypeName

                                                                                                      type TypeName = ObjectTypeName | PrimitiveTypeName;

                                                                                                        Namespaces

                                                                                                        namespace is

                                                                                                        namespace is {}

                                                                                                          function all

                                                                                                          all: (predicate: Predicate, ...values: unknown[]) => boolean;

                                                                                                            function any

                                                                                                            any: (predicate: Predicate | Predicate[], ...values: unknown[]) => boolean;

                                                                                                              function array

                                                                                                              array: <T = unknown>(
                                                                                                              value: unknown,
                                                                                                              assertion?: (value: T) => value is T
                                                                                                              ) => value is T[];

                                                                                                                function arrayBuffer

                                                                                                                arrayBuffer: (value: unknown) => value is ArrayBuffer;

                                                                                                                  function arrayLike

                                                                                                                  arrayLike: <T = unknown>(value: unknown) => value is ArrayLike<T>;

                                                                                                                    function asyncFunction

                                                                                                                    asyncFunction: <T = unknown>(
                                                                                                                    value: unknown
                                                                                                                    ) => value is (...args: any[]) => Promise<T>;

                                                                                                                      function asyncGenerator

                                                                                                                      asyncGenerator: (
                                                                                                                      value: unknown
                                                                                                                      ) => value is AsyncGenerator<unknown, any, unknown>;

                                                                                                                        function asyncGeneratorFunction

                                                                                                                        asyncGeneratorFunction: (
                                                                                                                        value: unknown
                                                                                                                        ) => value is (...args: any[]) => Promise<unknown>;

                                                                                                                          function asyncIterable

                                                                                                                          asyncIterable: <T = unknown>(value: unknown) => value is AsyncIterable<T>;

                                                                                                                            function bigint

                                                                                                                            bigint: (value: unknown) => value is bigint;

                                                                                                                              function bigInt64Array

                                                                                                                              bigInt64Array: (value: unknown) => value is BigInt64Array;

                                                                                                                                function bigUint64Array

                                                                                                                                bigUint64Array: (value: unknown) => value is BigUint64Array;

                                                                                                                                  function blob

                                                                                                                                  blob: (value: unknown) => value is Blob;

                                                                                                                                    function boolean

                                                                                                                                    boolean: (value: unknown) => value is boolean;

                                                                                                                                      function boundFunction

                                                                                                                                      boundFunction: (value: unknown) => value is Function;

                                                                                                                                        function buffer

                                                                                                                                        buffer: (value: unknown) => value is Buffer;

                                                                                                                                          function class_

                                                                                                                                          class_: (value: unknown) => value is Class<unknown, any[]>;

                                                                                                                                            function dataView

                                                                                                                                            dataView: (value: unknown) => value is DataView;

                                                                                                                                              function date

                                                                                                                                              date: (value: unknown) => value is Date;

                                                                                                                                                function directInstanceOf

                                                                                                                                                directInstanceOf: <T>(
                                                                                                                                                instance: unknown,
                                                                                                                                                class_: Class<T, any[]>
                                                                                                                                                ) => instance is T;

                                                                                                                                                  function domElement

                                                                                                                                                  domElement: (value: unknown) => value is HTMLElement;

                                                                                                                                                    function emptyArray

                                                                                                                                                    emptyArray: (value: unknown) => value is never[];

                                                                                                                                                      function emptyMap

                                                                                                                                                      emptyMap: (value: unknown) => value is Map<never, never>;

                                                                                                                                                        function emptyObject

                                                                                                                                                        emptyObject: <Key extends string | number | symbol = string>(
                                                                                                                                                        value: unknown
                                                                                                                                                        ) => value is Record<Key, never>;

                                                                                                                                                          function emptySet

                                                                                                                                                          emptySet: (value: unknown) => value is Set<never>;

                                                                                                                                                            function emptyString

                                                                                                                                                            emptyString: (value: unknown) => value is '';

                                                                                                                                                              function emptyStringOrWhitespace

                                                                                                                                                              emptyStringOrWhitespace: (value: unknown) => value is string;

                                                                                                                                                                function enumCase

                                                                                                                                                                enumCase: <T = unknown>(value: unknown, targetEnum: T) => boolean;

                                                                                                                                                                  function error

                                                                                                                                                                  error: (value: unknown) => value is Error;

                                                                                                                                                                    function evenInteger

                                                                                                                                                                    evenInteger: (value: number) => value is number;

                                                                                                                                                                      function falsy

                                                                                                                                                                      falsy: <T>(value: Falsy | T) => value is Falsy;

                                                                                                                                                                        function float32Array

                                                                                                                                                                        float32Array: (value: unknown) => value is Float32Array;

                                                                                                                                                                          function float64Array

                                                                                                                                                                          float64Array: (value: unknown) => value is Float64Array;

                                                                                                                                                                            function formData

                                                                                                                                                                            formData: (value: unknown) => value is FormData;

                                                                                                                                                                              function function_

                                                                                                                                                                              function_: (value: unknown) => value is Function;

                                                                                                                                                                                function generator

                                                                                                                                                                                generator: (value: unknown) => value is Generator<unknown, any, unknown>;

                                                                                                                                                                                  function generatorFunction

                                                                                                                                                                                  generatorFunction: (value: unknown) => value is GeneratorFunction;

                                                                                                                                                                                    function infinite

                                                                                                                                                                                    infinite: (value: unknown) => value is number;

                                                                                                                                                                                      function inRange

                                                                                                                                                                                      inRange: (value: number, range: number | number[]) => value is number;

                                                                                                                                                                                        function int16Array

                                                                                                                                                                                        int16Array: (value: unknown) => value is Int16Array;

                                                                                                                                                                                          function int32Array

                                                                                                                                                                                          int32Array: (value: unknown) => value is Int32Array;

                                                                                                                                                                                            function int8Array

                                                                                                                                                                                            int8Array: (value: unknown) => value is Int8Array;

                                                                                                                                                                                              function integer

                                                                                                                                                                                              integer: (value: unknown) => value is number;

                                                                                                                                                                                                function iterable

                                                                                                                                                                                                iterable: <T = unknown>(value: unknown) => value is Iterable<T>;

                                                                                                                                                                                                  function map

                                                                                                                                                                                                  map: <Key = unknown, Value = unknown>(
                                                                                                                                                                                                  value: unknown
                                                                                                                                                                                                  ) => value is Map<Key, Value>;

                                                                                                                                                                                                    function nan

                                                                                                                                                                                                    nan: (value: unknown) => boolean;

                                                                                                                                                                                                      function nativePromise

                                                                                                                                                                                                      nativePromise: <T = unknown>(value: unknown) => value is Promise<T>;

                                                                                                                                                                                                        function nodeStream

                                                                                                                                                                                                        nodeStream: (value: unknown) => value is NodeStream;

                                                                                                                                                                                                          function nonEmptyArray

                                                                                                                                                                                                          nonEmptyArray: (value: unknown) => value is [unknown, ...unknown[]];

                                                                                                                                                                                                            function nonEmptyMap

                                                                                                                                                                                                            nonEmptyMap: <Key = unknown, Value = unknown>(
                                                                                                                                                                                                            value: unknown
                                                                                                                                                                                                            ) => value is Map<Key, Value>;

                                                                                                                                                                                                              function nonEmptyObject

                                                                                                                                                                                                              nonEmptyObject: <Key extends string | number | symbol = string, Value = unknown>(
                                                                                                                                                                                                              value: unknown
                                                                                                                                                                                                              ) => value is Record<Key, Value>;

                                                                                                                                                                                                                function nonEmptySet

                                                                                                                                                                                                                nonEmptySet: <T = unknown>(value: unknown) => value is Set<T>;

                                                                                                                                                                                                                  function nonEmptyString

                                                                                                                                                                                                                  nonEmptyString: (value: unknown) => value is string;

                                                                                                                                                                                                                    function nonEmptyStringAndNotWhitespace

                                                                                                                                                                                                                    nonEmptyStringAndNotWhitespace: (value: unknown) => value is string;

                                                                                                                                                                                                                      function null_

                                                                                                                                                                                                                      null_: (value: unknown) => value is null;

                                                                                                                                                                                                                        function nullOrUndefined

                                                                                                                                                                                                                        nullOrUndefined: (value: unknown) => value is null;

                                                                                                                                                                                                                          function number

                                                                                                                                                                                                                          number: (value: unknown) => value is number;

                                                                                                                                                                                                                            function numericString

                                                                                                                                                                                                                            numericString: (value: unknown) => value is string;

                                                                                                                                                                                                                              function object

                                                                                                                                                                                                                              object: (value: unknown) => value is object;

                                                                                                                                                                                                                                function observable

                                                                                                                                                                                                                                observable: (value: unknown) => value is ObservableLike;

                                                                                                                                                                                                                                  function oddInteger

                                                                                                                                                                                                                                  oddInteger: (value: number) => value is number;

                                                                                                                                                                                                                                    function plainObject

                                                                                                                                                                                                                                    plainObject: <Value = unknown>(
                                                                                                                                                                                                                                    value: unknown
                                                                                                                                                                                                                                    ) => value is Record<PropertyKey, Value>;

                                                                                                                                                                                                                                      function primitive

                                                                                                                                                                                                                                      primitive: (value: unknown) => value is Primitive;

                                                                                                                                                                                                                                        function promise

                                                                                                                                                                                                                                        promise: <T = unknown>(value: unknown) => value is Promise<T>;

                                                                                                                                                                                                                                          function propertyKey

                                                                                                                                                                                                                                          propertyKey: (value: unknown) => value is PropertyKey;

                                                                                                                                                                                                                                            function regExp

                                                                                                                                                                                                                                            regExp: (value: unknown) => value is RegExp;

                                                                                                                                                                                                                                              function safeInteger

                                                                                                                                                                                                                                              safeInteger: (value: unknown) => value is number;

                                                                                                                                                                                                                                                function set

                                                                                                                                                                                                                                                set: <T = unknown>(value: unknown) => value is Set<T>;

                                                                                                                                                                                                                                                  function sharedArrayBuffer

                                                                                                                                                                                                                                                  sharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer;

                                                                                                                                                                                                                                                    function string

                                                                                                                                                                                                                                                    string: (value: unknown) => value is string;

                                                                                                                                                                                                                                                      function symbol

                                                                                                                                                                                                                                                      symbol: (value: unknown) => value is symbol;

                                                                                                                                                                                                                                                        function truthy

                                                                                                                                                                                                                                                        truthy: <T>(value: T | Falsy) => value is T;

                                                                                                                                                                                                                                                          function typedArray

                                                                                                                                                                                                                                                          typedArray: (value: unknown) => value is TypedArray;

                                                                                                                                                                                                                                                            function uint16Array

                                                                                                                                                                                                                                                            uint16Array: (value: unknown) => value is Uint16Array;

                                                                                                                                                                                                                                                              function uint32Array

                                                                                                                                                                                                                                                              uint32Array: (value: unknown) => value is Uint32Array;

                                                                                                                                                                                                                                                                function uint8Array

                                                                                                                                                                                                                                                                uint8Array: (value: unknown) => value is Uint8Array;

                                                                                                                                                                                                                                                                  function uint8ClampedArray

                                                                                                                                                                                                                                                                  uint8ClampedArray: (value: unknown) => value is Uint8ClampedArray;

                                                                                                                                                                                                                                                                    function undefined

                                                                                                                                                                                                                                                                    undefined: (value: unknown) => value is undefined;

                                                                                                                                                                                                                                                                      function urlInstance

                                                                                                                                                                                                                                                                      urlInstance: (value: unknown) => value is URL;

                                                                                                                                                                                                                                                                        function urlSearchParams

                                                                                                                                                                                                                                                                        urlSearchParams: (value: unknown) => value is URLSearchParams;

                                                                                                                                                                                                                                                                          function urlString

                                                                                                                                                                                                                                                                          urlString: (value: unknown) => value is string;

                                                                                                                                                                                                                                                                            function weakMap

                                                                                                                                                                                                                                                                            weakMap: <Key extends object = object, Value = unknown>(
                                                                                                                                                                                                                                                                            value: unknown
                                                                                                                                                                                                                                                                            ) => value is WeakMap<Key, Value>;

                                                                                                                                                                                                                                                                              function weakRef

                                                                                                                                                                                                                                                                              weakRef: (value: unknown) => value is WeakRef<object>;

                                                                                                                                                                                                                                                                                function weakSet

                                                                                                                                                                                                                                                                                weakSet: (value: unknown) => value is WeakSet<object>;

                                                                                                                                                                                                                                                                                  Package Files (2)

                                                                                                                                                                                                                                                                                  Dependencies (0)

                                                                                                                                                                                                                                                                                  No dependencies.

                                                                                                                                                                                                                                                                                  Dev Dependencies (13)

                                                                                                                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                                                                                                                  No peer dependencies.

                                                                                                                                                                                                                                                                                  Badge

                                                                                                                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@sindresorhus/is.

                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@sindresorhus/is)
                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/@sindresorhus/is"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>