is-what 4.1.16 → 5.0.0

package/dist/isAnyObject.d.ts

@@ -0,0 +1,6 @@
+import { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with
+ * different prototypes)
+ */
+export declare function isAnyObject(payload: unknown): payload is PlainObject;

package/dist/isAnyObject.js

@@ -0,0 +1,8 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with
+ * different prototypes)
+ */
+export function isAnyObject(payload) {
+    return getType(payload) === 'Object';
+}

package/dist/isArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an array */
+export declare function isArray(payload: unknown): payload is unknown[];

package/dist/isArray.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an array */
+export function isArray(payload) {
+    return getType(payload) === 'Array';
+}

package/dist/isBlob.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Blob */
+export declare function isBlob(payload: unknown): payload is Blob;

package/dist/isBlob.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Blob */
+export function isBlob(payload) {
+    return getType(payload) === 'Blob';
+}

package/dist/isBoolean.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a boolean */
+export declare function isBoolean(payload: unknown): payload is boolean;

package/dist/isBoolean.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a boolean */
+export function isBoolean(payload) {
+    return getType(payload) === 'Boolean';
+}

package/dist/isDate.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Date, and that the date is valid */
+export declare function isDate(payload: unknown): payload is Date;

package/dist/isDate.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Date, and that the date is valid */
+export function isDate(payload) {
+    return getType(payload) === 'Date' && !isNaN(payload);
+}

package/dist/isEmptyArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a an empty array */
+export declare function isEmptyArray(payload: unknown): payload is [];

package/dist/isEmptyArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an empty array */
+export function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}

package/dist/isEmptyObject.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export declare function isEmptyObject(payload: unknown): payload is {
+    [K in string | symbol | number]: never;
+};

package/dist/isEmptyObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}

package/dist/isEmptyString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is '' */
+export declare function isEmptyString(payload: unknown): payload is string;

package/dist/isEmptyString.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is '' */
+export function isEmptyString(payload) {
+    return payload === '';
+}

package/dist/isError.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an Error */
+export declare function isError(payload: unknown): payload is Error;

package/dist/isError.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an Error */
+export function isError(payload) {
+    return getType(payload) === 'Error' || payload instanceof Error;
+}

package/dist/isFile.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a File */
+export declare function isFile(payload: unknown): payload is File;

package/dist/isFile.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a File */
+export function isFile(payload) {
+    return getType(payload) === 'File';
+}

package/dist/isFullArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a an array with at least 1 item */
+export declare function isFullArray(payload: unknown): payload is unknown[];

package/dist/isFullArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an array with at least 1 item */
+export function isFullArray(payload) {
+    return isArray(payload) && payload.length > 0;
+}

package/dist/isFullObject.d.ts

@@ -0,0 +1,6 @@
+import { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export declare function isFullObject(payload: unknown): payload is PlainObject;

package/dist/isFullObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isFullObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length > 0;
+}

package/dist/isFullString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a string, BUT returns false for '' */
+export declare function isFullString(payload: unknown): payload is string;

package/dist/isFullString.js

@@ -0,0 +1,5 @@
+import { isString } from './isString.js';
+/** Returns whether the payload is a string, BUT returns false for '' */
+export function isFullString(payload) {
+    return isString(payload) && payload !== '';
+}

package/dist/isFunction.d.ts

@@ -0,0 +1,3 @@
+export type AnyFunction = (...args: unknown[]) => unknown;
+/** Returns whether the payload is a function (regular or async) */
+export declare function isFunction(payload: unknown): payload is AnyFunction;

package/dist/isFunction.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is a function (regular or async) */
+export function isFunction(payload) {
+    return typeof payload === 'function';
+}

package/dist/isInstanceOf.d.ts

@@ -0,0 +1,23 @@
+import { AnyClass } from './isType.js';
+type GlobalClassName = {
+    [K in keyof typeof globalThis]: (typeof globalThis)[K] extends AnyClass ? K : never;
+}[keyof typeof globalThis];
+/**
+ * Checks if a value is an instance of a class or a class name. Useful when you want to check if a
+ * value is an instance of a class that may not be defined in the current scope. For example, if you
+ * want to check if a value is an `OffscreenCanvas` instance, you might not want to do the song and
+ * dance of using `typeof OffscreenCanvas !== 'undefined'` and then shimming `OffscreenCanvas` if
+ * the types aren't around.
+ *
+ * @example
+ *   if (isInstanceOf(value, 'OffscreenCanvas')) {
+ *     // value is an OffscreenCanvas
+ *   }
+ *
+ * @param value The value to recursively check
+ * @param class_ A string or class that the value should be an instance of
+ */
+export declare function isInstanceOf<T extends AnyClass>(value: unknown, class_: T): value is T;
+export declare function isInstanceOf<K extends GlobalClassName>(value: unknown, className: K): value is (typeof globalThis)[K];
+export declare function isInstanceOf(value: unknown, className: string): value is object;
+export {};

package/dist/isInstanceOf.js

@@ -0,0 +1,20 @@
+import { getType } from './getType.js';
+import { isType } from './isType.js';
+export function isInstanceOf(value, classOrClassName) {
+    if (typeof classOrClassName === 'function') {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (isType(p, classOrClassName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    else {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (getType(p) === classOrClassName) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/isMap.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Map */
+export declare function isMap(payload: unknown): payload is Map<unknown, unknown>;

package/dist/isMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Map */
+export function isMap(payload) {
+    return getType(payload) === 'Map';
+}

package/dist/isNaNValue.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`) */
+export declare function isNaNValue(payload: unknown): payload is typeof NaN;

package/dist/isNaNValue.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`) */
+export function isNaNValue(payload) {
+    return getType(payload) === 'Number' && isNaN(payload);
+}

package/dist/isNegativeNumber.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a negative number (but not 0) */
+export declare function isNegativeNumber(payload: unknown): payload is number;

package/dist/isNegativeNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a negative number (but not 0) */
+export function isNegativeNumber(payload) {
+    return isNumber(payload) && payload < 0;
+}

package/dist/isNull.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is null */
+export declare function isNull(payload: unknown): payload is null;

package/dist/isNull.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is null */
+export function isNull(payload) {
+    return getType(payload) === 'Null';
+}

package/dist/isNullOrUndefined.d.ts

@@ -0,0 +1,2 @@
+/** Returns true whether the payload is null or undefined */
+export declare const isNullOrUndefined: (payload: unknown) => payload is null | undefined;

package/dist/isNullOrUndefined.js

@@ -0,0 +1,5 @@
+import { isNull } from './isNull.js';
+import { /* tree-shaking no-side-effects-when-called */ isOneOf } from './isOneOf.js';
+import { isUndefined } from './isUndefined.js';
+/** Returns true whether the payload is null or undefined */
+export const isNullOrUndefined = isOneOf(isNull, isUndefined);

package/dist/isNumber.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ */
+export declare function isNumber(payload: unknown): payload is number;

package/dist/isNumber.js

@@ -0,0 +1,9 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ */
+export function isNumber(payload) {
+    return getType(payload) === 'Number' && !isNaN(payload);
+}

package/dist/isObject.d.ts

@@ -0,0 +1,6 @@
+import { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export declare function isObject(payload: unknown): payload is PlainObject;

package/dist/isObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isObject(payload) {
+    return isPlainObject(payload);
+}

package/dist/isObjectLike.d.ts

@@ -0,0 +1,9 @@
+import { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T This must be passed in < >
+ */
+export declare function isObjectLike<T extends PlainObject>(payload: unknown): payload is T;

package/dist/isObjectLike.js

@@ -0,0 +1,11 @@
+import { isAnyObject } from './isAnyObject.js';
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T This must be passed in < >
+ */
+export function isObjectLike(payload) {
+    return isAnyObject(payload);
+}

package/dist/isOneOf.d.ts

@@ -0,0 +1,54 @@
+type TypeGuard<A, B extends A> = (payload: A) => payload is B;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>): TypeGuard<A, B | C>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>): TypeGuard<A, B | C | D>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>): TypeGuard<A, B | C | D | E>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A, F extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>, e: TypeGuard<A, F>): TypeGuard<A, B | C | D | E | F>;
+export {};

package/dist/isOneOf.js

@@ -0,0 +1,15 @@
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export function isOneOf(a, b, c, d, e) {
+    return (value) => a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
+}

package/dist/isPlainObject.d.ts

@@ -0,0 +1,6 @@
+export type PlainObject = Record<string | number | symbol, unknown>;
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export declare function isPlainObject(payload: unknown): payload is PlainObject;

package/dist/isPlainObject.js

@@ -0,0 +1,11 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    const prototype = Object.getPrototypeOf(payload);
+    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}

package/dist/isPositiveNumber.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a positive number (but not 0) */
+export declare function isPositiveNumber(payload: unknown): payload is number;

package/dist/isPositiveNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a positive number (but not 0) */
+export function isPositiveNumber(payload) {
+    return isNumber(payload) && payload > 0;
+}

package/dist/isPrimitive.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String
+ *
+ * | Symbol)
+ */
+export declare function isPrimitive(payload: unknown): payload is boolean | null | undefined | number | string | symbol;

package/dist/isPrimitive.js

@@ -0,0 +1,19 @@
+import { isBoolean } from './isBoolean.js';
+import { isNull } from './isNull.js';
+import { isNumber } from './isNumber.js';
+import { isString } from './isString.js';
+import { isSymbol } from './isSymbol.js';
+import { isUndefined } from './isUndefined.js';
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String
+ *
+ * | Symbol)
+ */
+export function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload));
+}

package/dist/isPromise.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Promise */
+export declare function isPromise(payload: unknown): payload is Promise<unknown>;

package/dist/isPromise.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Promise */
+export function isPromise(payload) {
+    return getType(payload) === 'Promise';
+}

package/dist/isRegExp.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a regular expression (RegExp) */
+export declare function isRegExp(payload: unknown): payload is RegExp;

package/dist/isRegExp.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a regular expression (RegExp) */
+export function isRegExp(payload) {
+    return getType(payload) === 'RegExp';
+}

package/dist/isSet.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Set */
+export declare function isSet(payload: unknown): payload is Set<unknown>;

package/dist/isSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Set */
+export function isSet(payload) {
+    return getType(payload) === 'Set';
+}

package/dist/isString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a string */
+export declare function isString(payload: unknown): payload is string;

package/dist/isString.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a string */
+export function isString(payload) {
+    return getType(payload) === 'String';
+}

package/dist/isSymbol.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Symbol */
+export declare function isSymbol(payload: unknown): payload is symbol;

package/dist/isSymbol.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Symbol */
+export function isSymbol(payload) {
+    return getType(payload) === 'Symbol';
+}

package/dist/isType.d.ts

@@ -0,0 +1,10 @@
+import { AnyFunction } from './isFunction.js';
+export type AnyClass = new (...args: unknown[]) => unknown;
+/**
+ * Does a generic check to check that the given payload is of a given type. In cases like Number, it
+ * will return true for NaN as NaN is a Number (thanks javascript!); It will, however, differentiate
+ * between object and null
+ *
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ */
+export declare function isType<T extends AnyFunction | AnyClass>(payload: unknown, type: T): payload is T;

package/dist/isType.js

@@ -0,0 +1,19 @@
+import { getType } from './getType.js';
+/**
+ * Does a generic check to check that the given payload is of a given type. In cases like Number, it
+ * will return true for NaN as NaN is a Number (thanks javascript!); It will, however, differentiate
+ * between object and null
+ *
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ */
+export function isType(payload, type) {
+    if (!(type instanceof Function)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!Object.prototype.hasOwnProperty.call(type, 'prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    const name = type.name;
+    return getType(payload) === name || Boolean(payload && payload.constructor === type);
+}

package/dist/isUndefined.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is undefined */
+export declare function isUndefined(payload: unknown): payload is undefined;

package/dist/isUndefined.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is undefined */
+export function isUndefined(payload) {
+    return getType(payload) === 'Undefined';
+}

package/dist/isWeakMap.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a WeakMap */
+export declare function isWeakMap(payload: unknown): payload is WeakMap<WeakKey, unknown>;

package/dist/isWeakMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakMap */
+export function isWeakMap(payload) {
+    return getType(payload) === 'WeakMap';
+}

package/dist/isWeakSet.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a WeakSet */
+export declare function isWeakSet(payload: unknown): payload is WeakSet<WeakKey>;

package/dist/isWeakSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakSet */
+export function isWeakSet(payload) {
+    return getType(payload) === 'WeakSet';
+}