@mudbean/is 2.0.2

package/es/types/intl.d.ts

@@ -0,0 +1,120 @@
+/**
+ * # 检测 `input` 是否是 `Intl.Collator` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.Collator` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlCollator } from '@mudbean/is';
+ *
+ * console.log(isIntlCollator(new Intl.Collator())); // true
+ *
+ * console.log(isIntlCollator(new Intl.DateTimeFormat())); // false
+ * ```
+ */
+export declare function isIntlCollator(input: any): input is Intl.Collator;
+/**
+ * # 检测 `input` 是否是 `Intl.DateTimeFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DateTimeFormat` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlDateTimeFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlDateTimeFormat(new Intl.DateTimeFormat())); // true
+ *
+ * console.log(isIntlDateTimeFormat('hello')); // false
+ * console.log(isIntlDateTimeFormat(1)); // false
+ * console.log(isIntlDateTimeFormat(true)); // false
+ * ```
+ */
+export declare function isIntlDateTimeFormat(input: any): input is Intl.DateTimeFormat;
+/**
+ * # 检测 `input` 是否是 `Intl.DisplayNames` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DisplayNames` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlDisplayNames } from '@mudbean/is';
+ *
+ * console.log(isIntlDisplayNames(new Intl.DisplayNames())); // true
+ *
+ * console.log(isIntlDisplayNames(new Intl.Locale())); // false
+ * ```
+ */
+export declare function isIntlDisplayNames(input: any): input is Intl.DisplayNames;
+/**
+ * #检测 `input` 是否是 `Intl.DurationFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DurationFormat` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlDurationFormat } from '@mudbean/is';
+ *
+ * ```
+ *
+ */
+/**
+ * # 检测 `input` 是否是 `Intl.ListFormat` 类型
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.ListFormat` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlListFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlListFormat(new Intl.ListFormat())); // true
+ *
+ * console.log(isIntlListFormat(new Intl.DateTimeFormat())); // false
+ * console.log(isIntlListFormat(1)); // false
+ * console.log(isIntlListFormat('1')); // false
+ * console.log(isIntlListFormat(null)); // false
+ * ```
+ */
+export declare function isIntlListFormat(input: any): input is Intl.ListFormat;
+/**
+ * # 检测 `input` 是否是 `Intl.Locale` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.Locale` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlLocale } from '@mudbean/is';
+ *
+ * console.log(isIntlLocale(new Intl.Locale())); // true
+ *
+ * console.log(isIntlLocale('en')); // false
+ * console.log(isIntlLocale(1)); // false
+ * ```
+ */
+export declare function isIntlLocale(input: any): input is Intl.Locale;
+/**
+ * # 检测 `input` 是否是 `Intl.NumberFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.NumberFormat` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlNumberFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlNumberFormat(new Intl.NumberFormat())); // true
+ *
+ * console.log(isIntlNumberFormat(123)); // false
+ * console.log(isIntlNumberFormat('123')); // false
+ * console.log(isIntlNumberFormat(new Date())); // false
+ * console.log(isIntlNumberFormat(new Date(0))); // false
+ * ```
+ */
+export declare function isIntlNumberFormat(input: any): input is Intl.NumberFormat;

package/es/types/isArray.d.ts

@@ -0,0 +1,281 @@
+/**
+ * # 检测 `input` 是否是 `Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isArray } from '@mudbean/is';
+ *
+ * console.log(isArray([1,2,3])) // true
+ * console.log(isArray({})) // false
+ * console.log(isArray(new Set())) // false
+ * ```
+ */
+export declare function isArray<T = any>(input: any): input is Array<T>;
+/**
+ * # 检测 `input` 是否是空数组
+ *
+ * @param input - 待检测的数据，任意数组
+ * @returns 返回 `true` 则说明该数据 `input` 为长度为 0 的空数组 ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isEmptyArray } from '@mudbean/is';
+ *
+ * console.log(isEmptyArray([])) // true
+ *
+ * console.log(isEmptyArray([1,2,3])) // false
+ * console.log(isEmptyArray({})) // TypeError
+ * console.log(isEmptyArray(new Set())) // false
+ * ```
+ */
+export declare function isEmptyArray(input: any[]): boolean;
+/**
+ * # 检测 `input` 是否是 `Set` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isSet } from '@mudbean/is';
+ *
+ * console.log(isSet(new Set())) // true
+ * console.log(isSet({})) // false
+ * console.log(isSet([])) // false
+ * ```
+ */
+export declare function isSet<T = any>(input: any): input is Set<T>;
+/**
+ * # 检测 `input` 是否是 `WeakSet` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `WeakSet` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isWeakSet } from '@mudbean/is';
+ *
+ * console.log(isWeakSet(new WeakSet())) // true
+ *
+ * console.log(isWeakSet({})) // false
+ * console.log(isWeakSet([])) // false
+ * console.log(isWeakSet(1)) // false
+ * ```
+ */
+export declare function isWeakSet<T extends WeakKey>(input: any): input is WeakSet<T>;
+/**
+ * # 检测 `input` 是否是 `Bigint64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `BigInt64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isBigInt64Array } from '@mudbean/is';
+ *
+ * console.log(isBigInt64Array(new BigInt64Array())) // true
+ *
+ * console.log(isBigInt64Array({})) // false
+ * console.log(isBigInt64Array([])) // false
+ *
+ * ```
+ */
+export declare function isBigInt64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is BigInt64Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `BigUint64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `BigUint64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isBigUint64Array } from '@mudbean/is';
+ *
+ * console.log(isBigUint64Array(new BigUint64Array())) // true
+ *
+ * console.log(isBigUint64Array({})) // false
+ * console.log(isBigUint64Array([])) // false
+ * console.log(isBigUint64Array(1)) // false
+ * ```
+ */
+export declare function isBigUint64Array<T extends ArrayBufferLike = ArrayBufferLike>(input: any): input is BigUint64Array<T>;
+/**
+ * # 检测 `input` 是否是 `ArrayBuffer` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ArrayBuffer` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isArrayBuffer } from '@mudbean/is';
+ *
+ * console.log(isArrayBuffer(new ArrayBuffer(8))) // true
+ *
+ * console.log(isArrayBuffer({})) // false
+ * ```
+ */
+export declare function isArrayBuffer(input: any): input is ArrayBuffer;
+/**
+ * # 检测 `input` 是否是 `int8Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Int8Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isInt8Array } from '@mudbean/is';
+ *
+ * console.log(isInt8Array(new Int8Array())) // true
+ *
+ * console.log(isInt8Array({})) // false
+ * console.log(isInt8Array([])) // false
+ * console.log(isInt8Array(1)) // false
+ * ```
+ */
+export declare function isInt8Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Int8Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `uint8Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint8Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint8Array } from '@mudbean/is';
+ *
+ * console.log(isUint8Array(new Uint8Array())) // true
+ *
+ * console.log(isUint8Array({})) // false
+ * console.log(isUint8Array([])) // false
+ * console.log(isUint8Array(1)) // false
+ * ```
+ */
+export declare function isUint8Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Uint8Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `int16Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Int16Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isInt16Array } from '@mudbean/is';
+ *
+ * console.log(isInt16Array(new Int16Array())) // true
+ *
+ * console.log(isInt16Array({})) // false
+ * console.log(isInt16Array([])) // false
+ * console.log(isInt16Array(1)) // false
+ * ```
+ */
+export declare function isInt16Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Int16Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `uint16Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint16Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ *
+ * import  { isUint16Array } from '@mudbean/is';
+ *
+ * console.log(isUint16Array(new Uint16Array())) // true
+ *
+ * console.log(isUint16Array({})) // false
+ * console.log(isUint16Array([])) // false
+ * console.log(isUint16Array(1)) // false
+ * ```
+ */
+export declare function isUint16Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Uint16Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `uint32Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint32Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint32Array } from '@mudbean/is';
+ *
+ * console.log(isUint32Array(new Uint32Array())) // true
+ *
+ * console.log(isUint32Array({})) // false
+ * console.log(isUint32Array([])) // false
+ * console.log(isUint32Array(1)) // false
+ * ```
+ */
+export declare function isUint32Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Uint32Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `float32Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Float32Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isFloat32Array } from '@mudbean/is';
+ *
+ * console.log(isFloat32Array(new Float32Array())) // true
+ *
+ * console.log(isFloat32Array({})) // false
+ * console.log(isFloat32Array([])) // false
+ * console.log(isFloat32Array(1)) // false
+ * ```
+ */
+export declare function isFloat32Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Float32Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `float64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Float64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isFloat64Array } from '@mudbean/is';
+ *
+ * console.log(isFloat64Array(new Float64Array())) // true
+ *
+ * console.log(isFloat64Array({})) // false
+ * console.log(isFloat64Array([])) // false
+ * console.log(isFloat64Array(1)) // false
+ * ```
+ */
+export declare function isFloat64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Float64Array<TArrayBuffer>;
+/**
+ * # 检测 `input` 是否是 `sharedArrayBuffer` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `SharedArrayBuffer` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isSharedArrayBuffer } from '@mudbean/is';
+ *
+ * console.log(isSharedArrayBuffer(new SharedArrayBuffer(8))) // true
+ *
+ * console.log(isSharedArrayBuffer({})) // false
+ * ```
+ */
+export declare function isSharedArrayBuffer(input: any): input is SharedArrayBuffer;
+/**
+ * # 检测 `input` 是否是 `uint8ClampedArray` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint8ClampedArray` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint8ClampedArray } from '@mudbean/is';
+ *
+ * console.log(isUint8ClampedArray(new Uint8ClampedArray())) // true
+ *
+ * console.log(isUint8ClampedArray({})) // false
+ * console.log(isUint8ClampedArray([])) // false
+ * console.log(isUint8ClampedArray(1)) // false
+ * ```
+ */
+export declare function isUint8ClampedArray<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(input: any): input is Uint8ClampedArray<TArrayBuffer>;

package/es/types/isBoolean.d.ts

@@ -0,0 +1,54 @@
+/**
+ * # 当前数据类型是否为 boolean
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `boolean` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isBoolean } from '@mudbean/is';
+ *
+ * console.log(isBoolean(true)); // true
+ * console.log(isBoolean(false)); // true
+ *
+ * console.log(isBoolean(1)); // false
+ * console.log(isBoolean('true')); // false
+ * ```
+ */
+export declare function isBoolean(input: any): input is boolean;
+/**
+ * # 当前数据类型是否为真值 true
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `true` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isTrue } from '@mudbean/is';
+ *
+ * console.log(isTrue(true)); // true
+ *
+ * console.log(isTrue(false)); // false
+ * console.log(isTrue(1)); // false
+ * console.log(isTrue('true')); // false
+ * ```
+ */
+export declare function isTrue(input: any): input is true;
+/**
+ * # 当前数据类型是否为真值 false
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `false` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isFalse } from '@mudbean/is';
+ *
+ * console.log(isFalse(false)); // true
+ *
+ * console.log(isFalse(true)); // false
+ * console.log(isFalse(1)); // false
+ * console.log(isFalse('true')); // false
+ * ```
+ */
+export declare function isFalse(input: any): input is false;

package/es/types/isFunction.d.ts

@@ -0,0 +1,97 @@
+/**
+ * # 检测 `input` 是否是 `function` 类型
+ *
+ * 函数分类：
+ * - 普通函数
+ * - 使用 `async` 标注的异步函数
+ * - 使用 `*` 标注的生成器函数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `function` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isFunction } from '@mudbean/is';
+ *
+ * console.log(isFunction(() => {})); // true
+ *
+ * console.log(isFunction(async () => {})); // false
+ * console.log(isFunction(function* () {})); // false
+ * ```
+ */
+export declare function isFunction<T extends (...args: any[]) => void>(input: any): input is T;
+/**
+ * # 检测 `input` 是否是 `Promise` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Promise` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isPromise } from '@mudbean/is';
+ *
+ * console.log(isPromise(new Promise(() => {}))); // true
+ * console.log(isPromise(() => {})); // false
+ * ```
+ */
+export declare function isPromise<T>(input: any): input is Promise<T>;
+/**
+ * # 检测 `input` 是否是 `AsyncFunction` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `async function` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isAsyncFunction } from '@mudbean/is';
+ *
+ * console.log(isAsyncFunction(async () => {})); // true
+ * console.log(isAsyncFunction(() => {})); // false
+ * ```
+ */
+export declare function isAsyncFunction<T extends (...args: any[]) => void>(input: any): input is () => Promise<T>;
+/**
+ * # 检测 `input` 是否是 `GeneratorFunction` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `generator function` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isGeneratorFunction } from '@mudbean/is';
+ *
+ * console.log(isGeneratorFunction(function* () {})); // true
+ * console.log(isGeneratorFunction(() => {})); // false
+ * ```
+ *
+ */
+export declare function isGeneratorFunction(input: any): input is GeneratorFunction;
+/**
+ * # 检测 `input` 是否是 `Generator` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Generator` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isGenerator } from '@mudbean/is';
+ *
+ * const log = (str) => console.log(str);
+ * const foo = function* () {
+ *  yield "a";
+ *  yield "b";
+ *  yield "c";
+ * }
+ *
+ * const gen = foo();
+ *
+ * log(gen.next().value);  // a
+ * log(gen.next().value);  // b
+ * log(gen.next().value);  // c
+ *
+ * console.log(isGenerator(foo)); // false
+ * console.log(isGenerator(gen)); // true
+ *
+ * ```
+ */
+export declare function isGenerator(input: any): input is Generator;

package/es/types/isNull.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 检测 Javascript 数据类型工具之: null
+ */
+/**
+ *
+ * 检测 `input` 是否是 `null` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `null` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isNull } from '@mudbean/is';
+ *
+ * console.log(isNull(null)); // true
+ *
+ * console.log(isNull(undefined)); // false
+ * console.log(isNull(1)); // false
+ * ```
+ */
+export declare function isNull(input: any): input is null;
+/**
+ *
+ * 检测 `input` 是否是 `undefined` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `undefined` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isUndefined } from '@mudbean/is';
+ *
+ * console.log(isUndefined(undefined)); // true
+ *
+ * console.log(isUndefined(null)); // false
+ * console.log(isUndefined(1)); // false
+ * ```
+ *
+ */
+export declare function isUndefined(input: any): input is undefined;