• Version 3.2.4
  • Published
  • 50.3 kB
  • 1 dependency
  • Apache-2.0 license


npm i @thi.ng/checks
yarn add @thi.ng/checks
pnpm add @thi.ng/checks


Collection of 70+ type, feature & value checks



function exists

exists: <T>(t: T) => t is T;

    function existsAndNotNull

    existsAndNotNull: <T>(x: T) => x is T;

      function hasBigInt

      hasBigInt: () => boolean;

        function hasCrypto

        hasCrypto: () => boolean;

          function hasMaxLength

          hasMaxLength: (len: number, x: ArrayLike<any>) => boolean;

            function hasMinLength

            hasMinLength: (len: number, x: ArrayLike<any>) => boolean;

              function hasPerformance

              hasPerformance: () => boolean;

                function hasWASM

                hasWASM: () => boolean;

                  function hasWebGL

                  hasWebGL: () => boolean;

                    function hasWebSocket

                    hasWebSocket: () => boolean;

                      function implementsFunction

                      implementsFunction: <T = any, K extends keyof T = any>(
                      x: any,
                      fn: K
                      ) => x is Pick<T, K>;

                        function isAlpha

                        isAlpha: (x: string) => boolean;

                          function isAlphaNum

                          isAlphaNum: (x: string) => boolean;

                            function isArray

                            isArray: (arg: any) => arg is any[];

                              function isArrayLike

                              isArrayLike: (x: any) => x is ArrayLike<any>;

                                function isASCII

                                isASCII: (x: string) => boolean;
                                • Returns true iff all chars are in ASCII range [0x00 .. 0x7f]

                                  Parameter x

                                function isAsyncIterable

                                isAsyncIterable: (x: any) => x is AsyncIterable<any>;

                                  function isBigInt

                                  isBigInt: (x: any) => x is bigint;

                                    function isBlob

                                    isBlob: (x: any) => x is Blob;

                                      function isBoolean

                                      isBoolean: (x: any) => x is boolean;

                                        function isChrome

                                        isChrome: () => boolean;

                                          function isDataURL

                                          isDataURL: (x: string) => boolean;

                                            function isDate

                                            isDate: (x: any) => x is Date;

                                              function isEven

                                              isEven: (x: number) => boolean;

                                                function isFalse

                                                isFalse: (x: any) => x is false;

                                                  function isFile

                                                  isFile: (x: any) => x is File;

                                                    function isFirefox

                                                    isFirefox: () => boolean;

                                                      function isFloatString

                                                      isFloatString: (x: string) => boolean;

                                                        function isFunction

                                                        isFunction: (x: any) => x is Function;

                                                          function isHex

                                                          isHex: (x: string) => boolean;

                                                            function isHexColor

                                                            isHexColor: (x: any) => x is string;

                                                              function isIE

                                                              isIE: () => boolean;

                                                                function isIllegalKey

                                                                isIllegalKey: (x: any) => boolean;
                                                                • Returns true, if given x is an illegal object key as per ILLEGAL_KEYS.

                                                                  Parameter x

                                                                  See Also

                                                                function isInRange

                                                                isInRange: (min: number, max: number, x: number) => boolean;

                                                                  function isInt32

                                                                  isInt32: (x: any) => x is number;

                                                                    function isIntString

                                                                    isIntString: (x: string) => boolean;

                                                                      function isIterable

                                                                      isIterable: (x: any) => x is Iterable<any>;

                                                                        function isMap

                                                                        isMap: (x: any) => x is Map<any, any>;

                                                                          function isMobile

                                                                          isMobile: () => boolean;

                                                                            function isNaN

                                                                            isNaN: (x: any) => boolean;

                                                                              function isNegative

                                                                              isNegative: (x: any) => x is number;

                                                                                function isNil

                                                                                isNil: (x: any) => x is null;
                                                                                • Checks if x is null or undefined.

                                                                                function isNode

                                                                                isNode: () => boolean;

                                                                                  function isNotStringAndIterable

                                                                                  isNotStringAndIterable: (x: any) => x is Iterable<any>;

                                                                                    function isNull

                                                                                    isNull: (x: any) => x is null;

                                                                                      function isNumber

                                                                                      isNumber: (x: any) => x is number;

                                                                                        function isNumeric

                                                                                        isNumeric: (x: string) => boolean;

                                                                                          function isNumericFloat

                                                                                          isNumericFloat: (x: string) => boolean;
                                                                                          • Returns true if given string only contains an integer or floating point number, optionally in scientific notiation (e.g. -123.45e-6).

                                                                                            Parameter x

                                                                                          function isNumericInt

                                                                                          isNumericInt: (x: string) => boolean;
                                                                                          • Returns true if given string contains only digits, and optionally, a sign prefix.

                                                                                            Parameter x

                                                                                          function isObject

                                                                                          isObject: (x: any) => x is Object;

                                                                                            function isOdd

                                                                                            isOdd: (x: number) => boolean;

                                                                                              function isPlainObject

                                                                                              isPlainObject: (x: any) => x is Record<string, any>;
                                                                                              • Similar to isObject, but also checks if prototype is that of Object (or null).

                                                                                                Parameter x

                                                                                              function isPositive

                                                                                              isPositive: (x: any) => x is number;

                                                                                                function isPrimitive

                                                                                                isPrimitive: (x: any) => x is string | number | boolean;
                                                                                                • Returns true if x is a string, number or boolean.

                                                                                                  Parameter x

                                                                                                function isPrintableASCII

                                                                                                isPrintableASCII: (x: string) => boolean;
                                                                                                • Returns true iff all chars are in printable ASCII range [0x20 .. 0x7e]

                                                                                                  Parameter x

                                                                                                function isPromise

                                                                                                isPromise: (x: any) => x is Promise<any>;

                                                                                                  function isPromiseLike

                                                                                                  isPromiseLike: (x: any) => x is Promise<any>;

                                                                                                    function isProtoPath

                                                                                                    isProtoPath: (path: string | number | readonly (string | number)[]) => boolean;
                                                                                                    • Returns true if given path contains any ILLEGAL_KEYS, i.e. could be used to poison the prototype chain of an object.

                                                                                                      Parameter path


                                                                                                      If given an array, each item is considered a single sub-path property and will be checked as is. If given a string it will be split using "." as delimiter and each item checked as is (same way array paths are handled).

                                                                                                      Original discussion here, implementation updated to be more encompassing: https://github.com/thi-ng/umbrella/pull/273

                                                                                                    function isRegExp

                                                                                                    isRegExp: (x: any) => x is RegExp;

                                                                                                      function isSafari

                                                                                                      isSafari: () => boolean;

                                                                                                        function isSet

                                                                                                        isSet: (x: any) => x is Set<any>;

                                                                                                          function isString

                                                                                                          isString: (x: any) => x is string;

                                                                                                            function isSymbol

                                                                                                            isSymbol: (x: any) => x is Symbol;

                                                                                                              function isTransferable

                                                                                                              isTransferable: (x: any) => boolean;

                                                                                                                function isTrue

                                                                                                                isTrue: (x: any) => x is boolean;

                                                                                                                  function isTypedArray

                                                                                                                  isTypedArray: (x: any) => x is TypedArray;

                                                                                                                    function isUint32

                                                                                                                    isUint32: (x: any) => x is number;

                                                                                                                      function isUndefined

                                                                                                                      isUndefined: (x: any) => x is undefined;

                                                                                                                        function isUUID

                                                                                                                        isUUID: (x: string) => boolean;

                                                                                                                          function isUUIDv4

                                                                                                                          isUUIDv4: (x: string) => boolean;

                                                                                                                            function isZero

                                                                                                                            isZero: (x: any) => x is 0;

                                                                                                                              Package Files (67)

                                                                                                                              Dependencies (1)

                                                                                                                              Dev Dependencies (7)

                                                                                                                              Peer Dependencies (0)

                                                                                                                              No peer dependencies.


                                                                                                                              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/@thi.ng/checks.

                                                                                                                              • Markdown
                                                                                                                              • HTML
                                                                                                                                <a href="https://www.jsdocs.io/package/@thi.ng/checks"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>