@mudbean/is 2.0.2 → 2.0.3

package/es/isBoolean.js

@@ -1 +1,67 @@
-import{typeOf as n}from"./typeOf.js";function r(r){return"boolean"===n(r)}function t(n){return!0===n}function o(n){return!1===n}export{r as isBoolean,o as isFalse,t as isTrue};
+import { typeOf } from './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(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;
+}
+
+export { isBoolean, isFalse, isTrue };

package/es/isFunction.js

@@ -1 +1,114 @@
-import{typeOf as n}from"./typeOf.js";function r(r){return"function"===n(r)}function t(r){return"promise"===n(r)}function o(r){return"asyncfunction"===n(r)}function u(r){return"generatorfunction"===n(r)}function e(r){return"generator"===n(r)}export{o as isAsyncFunction,r as isFunction,e as isGenerator,u as isGeneratorFunction,t as isPromise};
+import { typeOf } from './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(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(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(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(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(input) === 'generator';
+}
+
+export { isAsyncFunction, isFunction, isGenerator, isGeneratorFunction, isPromise };

package/es/isNull.js

@@ -1 +1,46 @@
-function n(n){return null===n}function r(n){return void 0===n}export{n as isNull,r as isUndefined};
+/**
+ * 检测 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;
+}
+
+export { isNull, isUndefined };

package/es/isNumber.js

@@ -1 +1,141 @@
-import{typeOf as n}from"./typeOf.js";function r(r){return"number"===n(r)}function t(r){return"bigint"===n(r)}function e(n){return Number.isNaN(n)}function u(n){return Number.isInteger(n)&&r(n)&&n>0}function i(n){return Number.isInteger(n)&&r(n)&&n<0}function o(n){return 0===n}export{t as isBigInt,e as isNaN,i as isNegativeInteger,r as isNumber,u as isPositiveInteger,o as isZero};
+import { typeOf } from './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(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(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;
+}
+
+export { isBigInt, isNaN, isNegativeInteger, isNumber, isPositiveInteger, isZero };

package/es/isObject.js

@@ -1 +1,193 @@
-import{typeOf as n}from"./typeOf.js";function t(t){return"object"===n(t)}function e(n){return t(n)&&0===Reflect.ownKeys(n).length}function r(t){return"date"===n(t)}function u(t){return"dataview"===n(t)}function o(t){return"map"===n(t)}function f(t){return"weakmap"===n(t)}export{u as isDataView,r as isDate,e as isEmptyObject,o as isMap,t as isPlainObject,f as isWeakMap};
+import { typeOf } from './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(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(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(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(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(input) === 'weakmap';
+}
+
+export { isDataView, isDate, isEmptyObject, isMap, isPlainObject, isWeakMap };

package/es/isString.js

@@ -1 +1,116 @@
-import{typeOf as r}from"./typeOf.js";function n(n){return"string"===r(n)}function t(n){return"regexp"===r(n)}function e(r){return n(r)&&""===r.valueOf()}function u(r){return n(r)&&""===r.valueOf().trim()}export{u as isBusinessEmptyString,e as isEmptyString,t as isRegExp,n as isString};
+import { typeOf } from './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(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(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() === '';
+}
+
+export { isBusinessEmptyString, isEmptyString, isRegExp, isString };