@mudbean/is 2.0.2 → 2.0.3

package/cjs/isArray.js

@@ -1 +1,340 @@
-"use strict";var r=require("./typeOf.js");function t(r){return Array.isArray(r)}exports.isArray=t,exports.isArrayBuffer=function(t){return"arraybuffer"===r.typeOf(t)},exports.isBigInt64Array=function(t){return"bigint64array"===r.typeOf(t)},exports.isBigUint64Array=function(t){return"biguint64array"===r.typeOf(t)},exports.isEmptyArray=function(r){if(t(r))return 0===r.length;throw new TypeError("参数必须为数组")},exports.isFloat32Array=function(t){return"float32array"===r.typeOf(t)},exports.isFloat64Array=function(t){return"float64array"===r.typeOf(t)},exports.isInt16Array=function(t){return"int16array"===r.typeOf(t)},exports.isInt8Array=function(t){return"int8array"===r.typeOf(t)},exports.isSet=function(t){return"set"===r.typeOf(t)},exports.isSharedArrayBuffer=function(t){return"sharedarraybuffer"===r.typeOf(t)},exports.isUint16Array=function(t){return"uint16array"===r.typeOf(t)},exports.isUint32Array=function(t){return"uint32array"===r.typeOf(t)},exports.isUint8Array=function(t){return"uint8array"===r.typeOf(t)},exports.isUint8ClampedArray=function(t){return"uint8clampedarray"===r.typeOf(t)},exports.isWeakSet=function(t){return"weakset"===r.typeOf(t)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: array
+ */
+/**
+ * # 检测 `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
+ * ```
+ */
+function isArray(input) {
+    return Array.isArray(input);
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isEmptyArray(input) {
+    if (isArray(input)) {
+        return input.length === 0;
+    }
+    throw new TypeError('参数必须为数组');
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isSet(input) {
+    return typeOf.typeOf(input) === 'set';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isWeakSet(input) {
+    return typeOf.typeOf(input) === 'weakset';
+}
+/**
+ * # 检测 `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
+ *
+ * ```
+ */
+function isBigInt64Array(input) {
+    return typeOf.typeOf(input) === 'bigint64array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isBigUint64Array(input) {
+    return typeOf.typeOf(input) === 'biguint64array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isArrayBuffer(input) {
+    return typeOf.typeOf(input) === '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
+ * ```
+ */
+function isInt8Array(input) {
+    return typeOf.typeOf(input) === 'int8array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isUint8Array(input) {
+    return typeOf.typeOf(input) === 'uint8array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isInt16Array(input) {
+    return typeOf.typeOf(input) === 'int16array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isUint16Array(input) {
+    return typeOf.typeOf(input) === 'uint16array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isUint32Array(input) {
+    return typeOf.typeOf(input) === 'uint32array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isFloat32Array(input) {
+    return typeOf.typeOf(input) === 'float32array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isFloat64Array(input) {
+    return typeOf.typeOf(input) === 'float64array';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isSharedArrayBuffer(input) {
+    return typeOf.typeOf(input) === '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
+ * ```
+ */
+function isUint8ClampedArray(input) {
+    return typeOf.typeOf(input) === 'uint8clampedarray';
+}
+
+exports.isArray = isArray;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isBigInt64Array = isBigInt64Array;
+exports.isBigUint64Array = isBigUint64Array;
+exports.isEmptyArray = isEmptyArray;
+exports.isFloat32Array = isFloat32Array;
+exports.isFloat64Array = isFloat64Array;
+exports.isInt16Array = isInt16Array;
+exports.isInt8Array = isInt8Array;
+exports.isSet = isSet;
+exports.isSharedArrayBuffer = isSharedArrayBuffer;
+exports.isUint16Array = isUint16Array;
+exports.isUint32Array = isUint32Array;
+exports.isUint8Array = isUint8Array;
+exports.isUint8ClampedArray = isUint8ClampedArray;
+exports.isWeakSet = isWeakSet;

package/cjs/isBoolean.js

@@ -1 +1,71 @@
-"use strict";var e=require("./typeOf.js");exports.isBoolean=function(r){return"boolean"===e.typeOf(r)},exports.isFalse=function(e){return!1===e},exports.isTrue=function(e){return!0===e};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: boolean
+ */
+/**
+ * # 当前数据类型是否为 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
+ * ```
+ */
+function isBoolean(input) {
+    return typeOf.typeOf(input) === '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
+ * ```
+ */
+function isTrue(input) {
+    return input === 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
+ * ```
+ */
+function isFalse(input) {
+    return input === false;
+}
+
+exports.isBoolean = isBoolean;
+exports.isFalse = isFalse;
+exports.isTrue = isTrue;

package/cjs/isFunction.js

@@ -1 +1,120 @@
-"use strict";var n=require("./typeOf.js");exports.isAsyncFunction=function(t){return"asyncfunction"===n.typeOf(t)},exports.isFunction=function(t){return"function"===n.typeOf(t)},exports.isGenerator=function(t){return"generator"===n.typeOf(t)},exports.isGeneratorFunction=function(t){return"generatorfunction"===n.typeOf(t)},exports.isPromise=function(t){return"promise"===n.typeOf(t)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: function
+ */
+/**
+ * # 检测 `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
+ * ```
+ */
+function isFunction(input) {
+    return 'function' === typeOf.typeOf(input);
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isPromise(input) {
+    return typeOf.typeOf(input) === 'promise';
+}
+/**
+ * # 检测 `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
+ * ```
+ */
+function isAsyncFunction(input) {
+    return typeOf.typeOf(input) === 'asyncfunction';
+}
+/**
+ * # 检测 `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
+ * ```
+ *
+ */
+function isGeneratorFunction(input) {
+    return typeOf.typeOf(input) === '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
+ *
+ * ```
+ */
+function isGenerator(input) {
+    return typeOf.typeOf(input) === 'generator';
+}
+
+exports.isAsyncFunction = isAsyncFunction;
+exports.isFunction = isFunction;
+exports.isGenerator = isGenerator;
+exports.isGeneratorFunction = isGeneratorFunction;
+exports.isPromise = isPromise;

package/cjs/isNull.js

@@ -1 +1,49 @@
-"use strict";exports.isNull=function(n){return null===n},exports.isUndefined=function(n){return void 0===n};
+'use strict';
+
+/**
+ * 检测 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
+ * ```
+ */
+function isNull(input) {
+    return input === 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
+ * ```
+ *
+ */
+function isUndefined(input) {
+    return input === undefined;
+}
+
+exports.isNull = isNull;
+exports.isUndefined = isUndefined;