@mudbean/is 2.0.2 → 2.0.3

package/cjs/isNumber.js

@@ -1 +1,148 @@
-"use strict";var e=require("./typeOf.js");function r(r){return"number"===e.typeOf(r)}exports.isBigInt=function(r){return"bigint"===e.typeOf(r)},exports.isNaN=function(e){return Number.isNaN(e)},exports.isNegativeInteger=function(e){return Number.isInteger(e)&&r(e)&&e<0},exports.isNumber=r,exports.isPositiveInteger=function(e){return Number.isInteger(e)&&r(e)&&e>0},exports.isZero=function(e){return 0===e};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: number
+ */
+/**
+ *
+ * 检测 `input` 是否是 `number` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `number` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isNumber } from '@mudbean/is';
+ *
+ * isNumber(123); // true
+ *
+ * isNumber('123'); // false
+ * ```
+ */
+function isNumber(input) {
+    return typeOf.typeOf(input) === 'number';
+}
+/**
+ *
+ * 检测 `input` 是否是 `BigInt` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `bigint` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isBigInt } from '@mudbean/is';
+ *
+ * isBigInt(123n); // true
+ *
+ * isBigInt('123'); // false
+ * isBigInt(123); // false
+ * isBigInt(true); // false
+ * ```
+ */
+function isBigInt(input) {
+    return typeOf.typeOf(input) === 'bigint';
+}
+/**
+ *
+ * 检测 `input` 是否是 `NaN` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `NaN` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isNaN } from '@mudbean/is';
+ *
+ * isNaN(NaN); // true
+ *
+ * isNaN('123'); // false
+ * ```
+ */
+function isNaN(input) {
+    return Number.isNaN(input);
+}
+/**
+ *
+ * 是否为正整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为正整数
+ * @example
+ *
+ * ```ts
+ * import { isPositiveInteger } from '@mudbean/is';
+ *
+ * isPositiveInteger(123); // true
+ * isPositiveInteger(1); // true
+ *
+ * isPositiveInteger(0); // false
+ * isPositiveInteger(-1); // true
+ * isPositiveInteger(false); // false
+ * isPositiveInteger(Infinity); // false
+ * isPositiveInteger('123'); // false
+ * isPositiveInteger(NaN); // false
+ * ```
+ */
+function isPositiveInteger(input) {
+    return Number.isInteger(input) && isNumber(input) && input > 0;
+}
+/**
+ *
+ * 是否为负整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为负整数
+ * @example
+ *
+ * ```ts
+ * import { isPositiveInteger } from '@mudbean/is';
+ *
+ * isPositiveInteger(-123); // true
+ * isPositiveInteger(-1); // true
+ *
+ * isPositiveInteger(0); // false
+ * isPositiveInteger(1); // true
+ * isPositiveInteger(false); // false
+ * isPositiveInteger(Infinity); // false
+ * isPositiveInteger('123'); // false
+ * isPositiveInteger(NaN); // false
+ * ```
+ */
+function isNegativeInteger(input) {
+    return Number.isInteger(input) && isNumber(input) && input < 0;
+}
+/**
+ *
+ * 是否为正整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 0
+ * @example
+ *
+ * ```ts
+ * import { isZero } from '@mudbean/is';
+ *
+ * isZero(0); // true
+ *
+ *
+ * isZero(123); // false
+ * isZero(1); // false
+ * isZero(false); // false
+ * isZero(Infinity); // false
+ * isZero('123'); // false
+ * isZero(NaN); // false
+ * ```
+ */
+function isZero(input) {
+    return input === 0;
+}
+
+exports.isBigInt = isBigInt;
+exports.isNaN = isNaN;
+exports.isNegativeInteger = isNegativeInteger;
+exports.isNumber = isNumber;
+exports.isPositiveInteger = isPositiveInteger;
+exports.isZero = isZero;

package/cjs/isObject.js

@@ -1 +1,200 @@
-"use strict";var t=require("./typeOf.js");function e(e){return"object"===t.typeOf(e)}exports.isDataView=function(e){return"dataview"===t.typeOf(e)},exports.isDate=function(e){return"date"===t.typeOf(e)},exports.isEmptyObject=function(t){return e(t)&&0===Reflect.ownKeys(t).length},exports.isMap=function(e){return"map"===t.typeOf(e)},exports.isPlainObject=e,exports.isWeakMap=function(e){return"weakmap"===t.typeOf(e)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: object
+ */
+/**
+ * # 检测 `input` 是否是类型 `plain object` （自定义的对象）
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `object` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isPlainObject } from '@mudbean/is';
+ *
+ * console.log(isPlainObject({})); // true
+ *
+ * // false ( Array is not an plain object )
+ * console.log(isPlainObject([]));
+ * // false ( Date is not an plain object )
+ * console.log(isPlainObject(new Date()));
+ * // false ( Map is not an plain object )
+ * console.log(isPlainObject(new Map()));
+ * ```
+ */
+function isPlainObject(input) {
+    return typeOf.typeOf(input) === 'object';
+}
+/**
+ * # 检测 `input` 是否是否是一个没有自己私有键的对象
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 是否为空的对象。不包含任何属性，包括 Symbol 或是不可被枚举的属性
+ * @example
+ *
+ * ```ts
+ * import { isEmptyObject } from '@mudbean/is';
+ *
+ * const a = new Object();
+ *
+ * console.log(isEmptyObject(a)); // true
+ * console.log(Reflect.ownKeys(input).length); // 0
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * Object.defineProperties(a, {
+ *     a: {
+ *       value: 10,
+ *       enumerable: false,
+ *       writable: false,
+ *       configurable: false,
+ *     },
+ * });
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 1
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 1
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * const b = Symbol('private proto');
+ *
+ * a[b] = b;
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 2
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 1
+ * console.log(Object.getOwnPropertySymbols(a).length); // 1
+ *
+ * delete a[a];
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 1
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 1
+ *
+ *
+ * delete a[b];
+ *
+ * console.log(isEmptyObject(a)); // true
+ * console.log(Reflect.ownKeys(input).length); // 0
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * ```
+ */
+function isEmptyObject(input) {
+    return isPlainObject(input) && Reflect.ownKeys(input).length === 0;
+}
+/**
+ * #  检测 data 是否是  类型{@link Date}
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Date` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isDate } from '@mudbean/is';
+ *
+ * console.log(isDate(new Date())); // true
+ * console.log(isDate(new Date(0))); // true
+ * console.log(isDate(new Date('2025-03-19'))); // true
+ * console.log(isDate(new Date(NaN))); // true
+ * console.log(isDate(new Date(undefined))); // true
+ * console.log(isDate(new Date(null))); // true
+ *
+ * // false ( Number 不是 Date )
+ * console.log(isDate(1));
+ * // false ( String 不是 Date )
+ * console.log(isDate('1'));
+ * ```
+ */
+function isDate(input) {
+    return typeOf.typeOf(input) === 'date';
+}
+/**
+ *
+ * 检测 `input` 是否是 `DataView` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `DataView` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isDataView } from '@mudbean/is';
+ *
+ * console.log(isDataView(new DataView(new ArrayBuffer(8)))); // true
+ *
+ * // false (ArrayBuffer 不是 DataView)
+ * console.log(isDataView(new ArrayBuffer(8)));
+ * ```
+ */
+function isDataView(input) {
+    return typeOf.typeOf(input) === 'dataview';
+}
+/**
+ *
+ * 检测 `input` 是否是 `Map` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Map` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isMap } from '@mudbean/is';
+ *
+ * console.log(isMap(new Map())); // true
+ *
+ * // false (WeakMap 不是 Map)
+ * console.log(isMap(new WeakMap()));
+ * // false (Set 不是 Map)
+ * console.log(isMap(new Set()));
+ * // false (WeakSet 不是 Map)
+ * console.log(isMap(new WeakSet()));
+ * // false (Array 不是 Map)
+ * console.log(isMap(new Array()));
+ * ```
+ */
+function isMap(input) {
+    return typeOf.typeOf(input) === 'map';
+}
+/**
+ *
+ * 检测 `input` 是否是 `WeakMap` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `WeakMap` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isWeakMap } from '@mudbean/is';
+ *
+ * console.log(isWeakMap(new WeakMap())); // true
+ *
+ * // false (Map is not WeakMap)
+ * console.log(isWeakMap(new Map()));
+ * // false (Set is not WeakMap)
+ * console.log(isWeakMap(new Set()));
+ * // false (WeakSet is not WeakMap)
+ * console.log(isWeakMap(new WeakSet()));
+ * // false (Array is not WeakMap)
+ * console.log(isWeakMap(new Array()));
+ * ```
+ */
+function isWeakMap(input) {
+    return typeOf.typeOf(input) === 'weakmap';
+}
+
+exports.isDataView = isDataView;
+exports.isDate = isDate;
+exports.isEmptyObject = isEmptyObject;
+exports.isMap = isMap;
+exports.isPlainObject = isPlainObject;
+exports.isWeakMap = isWeakMap;

package/cjs/isString.js

@@ -1 +1,121 @@
-"use strict";var t=require("./typeOf.js");function r(r){return"string"===t.typeOf(r)}exports.isBusinessEmptyString=function(t){return r(t)&&""===t.valueOf().trim()},exports.isEmptyString=function(t){return r(t)&&""===t.valueOf()},exports.isRegExp=function(r){return"regexp"===t.typeOf(r)},exports.isString=r;
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: string
+ */
+/**
+ * # 当前数据类型是否为 string
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isString } from '@mudbean/is';
+ *
+ * console.log(isString('hello')); // true
+ *
+ * // false (number 不是 string)
+ * console.log(isString(123));
+ * // false (boolean 不是 string)
+ * console.log(isString(true));
+ * // false (null 不是 string)
+ * console.log(isString(null));
+ * ```
+ */
+function isString(input) {
+    return typeOf.typeOf(input) === 'string';
+}
+/**
+ * # 检测 `input` 是否是 `RegExp` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `RegExp` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isRegExp } from '@mudbean/is';
+ *
+ * console.log(isRegExp(/abc/)); // true
+ * console.log(isRegExp(new RegExp('abc'))); // true
+ *
+ * // false (number 不是 RegExp)
+ * console.log(isRegExp(123));
+ * // false (string 不是 RegExp)
+ * console.log(isRegExp('abc'));
+ * // false (null 不是 RegExp)
+ * console.log(isRegExp(null));
+ * ```
+ */
+function isRegExp(input) {
+    return typeOf.typeOf(input) === 'regexp';
+}
+/**
+ * # 检测 `input` 是否是（绝对）空字符串
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` 且为 空字符串，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isEmptyString } from '@mudbean/is';
+ *
+ * console.log(isEmptyString('')); // true
+ * const.log(isEmptyString(new String())); // true
+ * const.log(isEmptyString(new String(''))); // true
+ *
+ *
+ * // 以下情况返回 false
+ * console.log(isEmptyString(' ')); // false
+ * console.log(isEmptyString('abc')); // false
+ * // false (number 不是 string)
+ * console.log(isEmptyString(123));
+ * // false (boolean 不是 string)
+ * console.log(isEmptyString(true));
+ * // false (null 不是 string)
+ * console.log(isEmptyString(null));
+ * ```
+ */
+function isEmptyString(input) {
+    return isString(input) && input.valueOf() === '';
+}
+/**
+ * # 检测 `input` 是否是（业务）空字符串
+ *
+ * 业务空字符串：指字符串开头和结尾的空格，以及中间连续的空格，都算作空字符串
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` 且为 业务空字符串，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isBusinessEmptyString } from '@mudbean/is';
+ *
+ * console.log(isBusinessEmptyString('')); // true
+ * console.log(isBusinessEmptyString(' ')); // true
+ * console.log(isBusinessEmptyString('  ')); // true
+ * console.log(isBusinessEmptyString(new String())); // true
+ * console.log(isBusinessEmptyString(new String(''))); // true
+ * console.log(isBusinessEmptyString(new String(' '))); // true
+ *
+ * // 以下情况返回 false
+ * console.log(isBusinessEmptyString('abc')); // false
+ * // false (number 不是 string)
+ * console.log(isBusinessEmptyString(123));
+ * // false (boolean 不是 string)
+ * console.log(isBusinessEmptyString(true));
+ * // false (null 不是 string)
+ * console.log(isBusinessEmptyString(null));
+ * ```
+ */
+function isBusinessEmptyString(input) {
+    return isString(input) && input.valueOf().trim() === '';
+}
+
+exports.isBusinessEmptyString = isBusinessEmptyString;
+exports.isEmptyString = isEmptyString;
+exports.isRegExp = isRegExp;
+exports.isString = isString;

package/cjs/isSymbol.js

@@ -1 +1,36 @@
-"use strict";var e=require("./typeOf.js");exports.isSymbol=function(r){return"symbol"===e.typeOf(r)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: symbol
+ */
+/**
+ * #  检测 `input` 是否是 `Symbol` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `symbol` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isSymbol } from '@mudbean/is';
+ *
+ * console.log(isSymbol(Symbol('test'))); // true
+ *
+ * // false (string 非 symbol)
+ * console.log(isSymbol('test'));
+ * // false (number 非 symbol)
+ * console.log(isSymbol(123));
+ * // false (boolean 非 symbol)
+ * console.log(isSymbol(true));
+ * // false (null 非 symbol)
+ * console.log(isSymbol(null));
+ * // false (undefined 非 symbol)
+ * console.log(isSymbol(undefined));
+ * ```
+ */
+function isSymbol(input) {
+    return typeOf.typeOf(input) === 'symbol';
+}
+
+exports.isSymbol = isSymbol;

package/cjs/isType.js

@@ -1 +1,16 @@
-"use strict";exports.isType=function(t,e){return void 0===e||("function"==typeof e?e(t):e)};
+'use strict';
+
+/**
+ *  `input` 类型收缩
+ */
+/**    */
+function isType(input, judgingConditions) {
+    if (judgingConditions === undefined)
+        return true;
+    if (typeof judgingConditions === 'function') {
+        return judgingConditions(input);
+    }
+    return judgingConditions;
+}
+
+exports.isType = isType;

package/cjs/typeOf.js

@@ -1 +1,72 @@
-"use strict";exports.typeOf=function(r){const e=typeof r;if("object"!==e&&"function"!==e)return e;const o=Reflect.apply(Object.prototype.toString,r,[]).replace(/^.*\s(.*)]$/,"$1").toLowerCase();return"error"!==o?o:r instanceof SyntaxError?"syntaxerror":r instanceof TypeError?"typeerror":r instanceof URIError?"urierror":r instanceof ReferenceError?"referenceerror":r instanceof AggregateError?"aggregateerror":r instanceof RangeError?"rangeerror":r instanceof EvalError?"evalerror":"error"};
+'use strict';
+
+/**
+ *  # 数据类型检测
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 检测数据类型的字符串表示（小写字母）
+ * @example
+ * ```ts
+ * import  { typeOf } from '@mudbean/is';
+ *
+ *  console.log(typeOf(1) === 'number'); // true
+ *  console.log(typeOf('1') === 'string'); // true
+ *  console.log(typeOf(null) === 'null'); // true
+ *  console.log(typeOf(undefined) === 'undefined'); // true
+ *  console.log(typeOf(true) === 'boolean'); // true
+ *  console.log(typeOf(Symbol()) === 'symbol');
+ *  console.log(typeOf(new Date()) === 'date');
+ *  console.log(typeOf([]) === 'array');
+ *  console.log(typeOf(new Set()) === 'set');
+ *  console.log(typeOf(new Map()) === 'map');
+ *  console.log(typeOf(new Error()) === 'error');
+ *  console.log(typeOf(new Promise(() => {})) === 'promise');
+ *    ...
+ * ```
+ */
+function typeOf(input) {
+    /**
+     * 使用 typeof 判断数据类型
+     */
+    const typeofValue = typeof input;
+    // 检验出原始数据类型
+    if ('object' !== typeofValue && 'function' !== typeofValue) {
+        return typeofValue;
+    }
+    /**
+     * # 通过 Object.prototype.toString.call(o) 判断数据类型
+     */
+    const toStringCallValue = Reflect.apply(Object.prototype.toString, input, [])
+        .replace(/^.*\s(.*)]$/, '$1')
+        .toLowerCase();
+    if ('error' !== toStringCallValue) {
+        return toStringCallValue;
+    }
+    if (input instanceof SyntaxError) {
+        return 'syntaxerror';
+    }
+    if (input instanceof TypeError) {
+        return 'typeerror';
+    }
+    if (input instanceof URIError) {
+        return 'urierror';
+    }
+    if (input instanceof ReferenceError) {
+        return 'referenceerror';
+    }
+    // if (input instanceof InternalError) {
+    //   return 'internalerror';
+    // }
+    if (input instanceof AggregateError) {
+        return 'aggregateerror';
+    }
+    if (input instanceof RangeError) {
+        return 'rangeerror';
+    }
+    if (input instanceof EvalError) {
+        return 'evalerror';
+    }
+    return 'error';
+}
+
+exports.typeOf = typeOf;