@mudbean/is 2.0.2

package/CHANGELOG.md

@@ -0,0 +1,134 @@
+# 版本日志
+
+## 2.0.2 (2026-6-9)
+
+- 维护注释信息
+
+## 2.0.1 (2026-3-24)
+
+- 维护注释信息
+
+## v2.0.0 (2025-12-24)
+
+- 更新包信息
+
+## v1.1.0 (2025-12-24)
+
+一件超级尴尬的事，打包的构建 package.json 文件没有包含 `sideEffects: false` ，消费端无法进行正确的 Tree Shaking
+
+## v1.0.8-beta.0 (2025-9-7)
+
+- for WechatMiniprogram
+
+## v1.0.7 (2025-7-25)
+
+- 修复文档
+
+## v1.0.6 (2025-7-25)
+
+- 修复文档
+
+## v1.0.6-test.0 (2025-7-24)
+
+- 么事
+
+## v1.0.5 (2025-7-14)
+
+- no unknown
+
+## v1.0.4 (2025-7-9)
+
+- 移除了 `isEmptyArray` 的类型检测
+
+## v1.0.3 (2025-7-4)
+
+- `isEmptyArray` 添加了范性，在数组为空数组时依旧保持原类型
+
+## v1.0.2 (2025-6-16)
+
+- 文档维护
+
+## v1.0.1 (2025-5-29)
+
+- `isType` 的第二参数现可接受一个参数，该参数可被用于判断后的该值类型来使用（见函数注释）
+
+## v1.0.0 （5 🈷️ 24 日 2025 年）
+
+由于版本号长期处于 1 一下，导致同一个项目多个版本
+
+- 添加了 `isZero`
+- 添加了 `isNegativeInteger`
+- 添加了 `isPositiveInteger`
+
+这三个看似有用实则没用的东西
+
+## v0.3.1-beta.0 （5 🈷️ 10 日 2025 年）
+
+- 好想一不小心就
+
+## v0.3.0 （5 🈷️ 9 日 2025 年）
+
+### ✨ 新增函数
+
+- 添加了 `isTrue` 函数，用于判断值是否是 `true`
+- 添加了 `isFalse` 函数，用于判断值是否是 `false`
+- 添加了 `isEmptyArray` 函数，用于判断值是否是空数组
+- 添加了 `isEmptyObject` 函数，用于判断值是否是空对象
+
+## v0.2.1 （5 🈷️ 9 日 20
+
+- 文档修复
+
+## 0.2.0(4 月 9 日 2025 年)
+
+### 功能添加 ✨
+
+- 添加了 `isEmptyString` 函数，用于判断字符串是否为空字符串，且不包含空格
+- 添加了 `isBusinessEmptyString`，用于判断字符串是否为空字符串，且包含空格
+
+## 0.1.5(3 月 27 日 2025 年)
+
+- 多次折腾，回归中文注释
+
+## 0.1.4(3 月 21 日 2025 年)
+
+- 通过 github actions 构建和发布包
+
+## 0.1.0(3 月 21 日 2025 年)
+
+- 修改了测试率徽章的显示方式
+
+## 0.0.7 (3 月 19 日 2025 年)
+
+- 维护了注释
+
+## 0.0.6 (3 月 19 日 2025 年)
+
+- 修复了 `isEvalError`、`isRangeError`、`isReferenceError`、`isSyntaxError`、`isTypeError`、`isURIError`、`isAggregateError` 返回值不准确的问题
+- 添加了 `isType` 函数
+
+## 0.0.5 (3 月 16 日 2025 年)
+
+- 上一个版本意外移除了打包的依赖 `tslib` 导致打包异常而未察觉，已修复
+
+## 0.0.4 (3 月 13 日 2025 年)
+
+- 添加测试率的徽章
+
+## 0.0.3 (3 月 13 日 2025 年)
+
+- 修复了已知 bug
+
+## 0.0.2 (3 月 7 日 2025 年)
+
+- 使用 [shields](https://img.shields.io) 构建徽章
+
+## 0.0.1 (3 月 7 日 2025 年)
+
+- 移除了 `isAtomics` 函数。因为 `Atomics` 仅是一个函数集合，没有实例。同样的还有 `Math、JSON、Reflect、Intl`
+- 移除了 `isWindow` 函数
+- 优化了 `typeOf` 函数，检测 `asyncFunction`、`generator`、`generatorFunction` 更精准
+
+## 0.0.0 (3 月 4 日 2025 年)
+
+- 初始化项目

package/LICENSE

@@ -0,0 +1,16 @@
+# MIT License
+
+Copyright (c) <2025> <Mr.MudBean>
+    
+Permission to use, copy, modify, and/or distribute this software for any  
+purpose with or without fee is hereby granted, provided that the above  
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES  
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF  
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR  
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES  
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN  
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF  
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ 

package/README.md

@@ -0,0 +1,136 @@
+# is
+
+[![version](<https://img.shields.io/npm/v/@mudbean/is.svg?logo=npm&logoColor=rgb(0,0,0)&label=版本号&labelColor=rgb(73,73,228)&color=rgb(0,0,0)>)](https://www.npmjs.com/package/@mudbean/is) [![issues 提交](<https://img.shields.io/badge/issues-提交-rgb(255,0,63)?logo=github>)](https://github.com/MrMudBean/is/issues)
+
+一个简单的类型判断工具
+
+## 使用
+
+```ts
+import { typeOf } from '@mudbean/is';
+
+const num = 1;
+
+if (typeOf(num) === 'number') {
+  console.log('num is number');
+} else {
+  console.log('num is not number');
+}
+```
+
+### 使用 `ts` 中的 is 类型判断来进行类型安全收缩
+
+```ts
+import { isString, isNumber } from '@mudbean/is';
+
+function doSomething(value: string | number) {
+  if (isString(value)) {
+    value.toLocaleUpperCase();
+  } else if (isNumber(value)) {
+    value.toFixed(2);
+  }
+}
+
+doSomething('hello'); // HELLO
+doSomething(1); // 1.00
+```
+
+### 向 `as` 说 'no'
+
+vitest
+
+```ts
+import { isType } from '@mudbean/is';
+
+interface Person {
+    name: string;
+    age: number;
+}
+
+
+function doSomething(value: string | number | boolean | ) {
+
+    // 将判断用作类型判断
+    if (isType<Person>(value, () => (value && value.name === 'Tom' && value.age === 18))) {
+      console.log('value is Person');
+      return;
+    }
+
+    /// 作为类型判定
+    if (isType<string>(value)) {
+      value.toLocaleUpperCase();
+      return;
+    }
+
+    /// 使用判断力
+    if (isType<boolean>(value, Boolean(value) === true )) {
+      console.log('value is true');
+      return;
+    }
+}
+```
+
+### 文档提供类型检测
+
+- `isString` 字符串、`String` 对象构建的字符串
+- `isEmptyString` 空字符串
+- `isBusinessEmptyString` 空字符串（去除首尾空格）
+- `isNumber` 数字、`Number` 对象构建的数字
+- `isBoolean` 布尔值、`Boolean` 对象构建的布尔值
+- `isTrue` 是否为 true
+- `isFalse` 是否为 false
+- `isNull` null
+- `isUndefined` undefined
+- `isNaN` `NaN`（`NaN` 是一个特殊的数值 `NaN !== NaN` 即便 `typeof NaN` 返回的是 `number`）
+- `isFunction` 函数
+- `isArray` 数组、`Array` 对象构建的数组
+- `isEmptyArray` 是否是空数组
+- `isSymbol` symbol
+- `isBigInt` 大整数
+- `isPlainObject` 对象（普通对象，非其他内置对象类型）
+- `isEmptyObject` 是否为空对象（没有私有键的对象）
+- `isPromise` Promise
+- `isAsyncFunction` 异步函数
+- `isDate` 时间
+- `isMap` Map
+- `isSet` Set
+- `isWeakMap` WeakMap
+- `isWeakSet` WeakSet
+- `isGenerator` 生成器
+- `isGeneratorFunction` 生成器函数
+- `isBigInt64Array` BigInt64Array
+- `isBigUint64Array` BigUint64Array
+- `isDataView` DataView
+- `isArrayBuffer` ArrayBuffer
+- `isRegExp` 正则、`RegExp` 对象构建的正则
+- `isSharedArrayBuffer` SharedArrayBuffer
+- `isUint8ClampedArray` Uint8ClampedArray
+- `isInt8Array` Int8Array
+- `isUint8Array` Uint8Array
+- `isTypedArray` TypedArray
+- `isInt16Array` Int16Array
+- `isUint16Array` Uint16Array
+- `isInt32Array` Int32Array
+- `isUint32Array` Uint32Array
+- `isFloat32Array` Float32Array
+- `isFloat64Array` Float64Array
+- `isIntlCollator` Intl.Collator
+- `isIntlDateTimeFormat` Intl.DateTimeFormat
+- `isIntlDisplayNames` Intl.DisplayNames
+- `isIntlListFormat` Intl.ListFormat
+- `isIntlLocale` Intl.Locale
+- `isIntlNumberFormat` Intl.NumberFormat
+- `isError` 错误
+- `isEvalError` eval 错误
+- `isRangeError` range 错误
+- `isReferenceError` reference 错误
+- `isSyntaxError` syntax 错误
+- `isTypeError` type 错误
+- `isURIError` uri 错误
+- `isAggregateError` aggregate 错误
+
+## 状态
+
+此软件包是 `@mudbean` 生态系统的一部分。
+它使用严格的 TypeScript 编写，并通过 Rollup 构建进行验证。
+虽然单元测试较少，但 API 稳定，并在生产环境中大量使用。

package/cjs/error.js

@@ -0,0 +1 @@
+"use strict";var r=require("./typeOf.js");exports.isAggregateError=function(e){return"aggregateerror"===r.typeOf(e)},exports.isError=function(e){return"error"===r.typeOf(e)},exports.isEvalError=function(e){return"evalerror"===r.typeOf(e)},exports.isRangeError=function(e){return"rangeerror"===r.typeOf(e)},exports.isReferenceError=function(e){return"referenceerror"===r.typeOf(e)},exports.isSyntaxError=function(e){return"syntaxerror"===r.typeOf(e)},exports.isTypeError=function(e){return"typeerror"===r.typeOf(e)},exports.isURIError=function(e){return"urierror"===r.typeOf(e)};

package/cjs/index.js

@@ -0,0 +1 @@
+"use strict";var r=require("./typeOf.js"),s=require("./isString.js"),i=require("./isNumber.js"),e=require("./isBoolean.js"),t=require("./isNull.js"),o=require("./isFunction.js"),a=require("./isArray.js"),p=require("./isObject.js"),n=require("./isSymbol.js"),x=require("./intl.js"),y=require("./error.js"),l=require("./isType.js");exports.typeOf=r.typeOf,exports.isBusinessEmptyString=s.isBusinessEmptyString,exports.isEmptyString=s.isEmptyString,exports.isRegExp=s.isRegExp,exports.isString=s.isString,exports.isBigInt=i.isBigInt,exports.isNaN=i.isNaN,exports.isNegativeInteger=i.isNegativeInteger,exports.isNumber=i.isNumber,exports.isPositiveInteger=i.isPositiveInteger,exports.isZero=i.isZero,exports.isBoolean=e.isBoolean,exports.isFalse=e.isFalse,exports.isTrue=e.isTrue,exports.isNull=t.isNull,exports.isUndefined=t.isUndefined,exports.isAsyncFunction=o.isAsyncFunction,exports.isFunction=o.isFunction,exports.isGenerator=o.isGenerator,exports.isGeneratorFunction=o.isGeneratorFunction,exports.isPromise=o.isPromise,exports.isArray=a.isArray,exports.isArrayBuffer=a.isArrayBuffer,exports.isBigInt64Array=a.isBigInt64Array,exports.isBigUint64Array=a.isBigUint64Array,exports.isEmptyArray=a.isEmptyArray,exports.isFloat32Array=a.isFloat32Array,exports.isFloat64Array=a.isFloat64Array,exports.isInt16Array=a.isInt16Array,exports.isInt8Array=a.isInt8Array,exports.isSet=a.isSet,exports.isSharedArrayBuffer=a.isSharedArrayBuffer,exports.isUint16Array=a.isUint16Array,exports.isUint32Array=a.isUint32Array,exports.isUint8Array=a.isUint8Array,exports.isUint8ClampedArray=a.isUint8ClampedArray,exports.isWeakSet=a.isWeakSet,exports.isDataView=p.isDataView,exports.isDate=p.isDate,exports.isEmptyObject=p.isEmptyObject,exports.isMap=p.isMap,exports.isPlainObject=p.isPlainObject,exports.isWeakMap=p.isWeakMap,exports.isSymbol=n.isSymbol,exports.isIntlCollator=x.isIntlCollator,exports.isIntlDateTimeFormat=x.isIntlDateTimeFormat,exports.isIntlDisplayNames=x.isIntlDisplayNames,exports.isIntlListFormat=x.isIntlListFormat,exports.isIntlLocale=x.isIntlLocale,exports.isIntlNumberFormat=x.isIntlNumberFormat,exports.isAggregateError=y.isAggregateError,exports.isError=y.isError,exports.isEvalError=y.isEvalError,exports.isRangeError=y.isRangeError,exports.isReferenceError=y.isReferenceError,exports.isSyntaxError=y.isSyntaxError,exports.isTypeError=y.isTypeError,exports.isURIError=y.isURIError,exports.isType=l.isType;

package/cjs/intl.js

@@ -0,0 +1 @@
+"use strict";var t=require("./typeOf.js");exports.isIntlCollator=function(e){return"intl.collator"===t.typeOf(e)},exports.isIntlDateTimeFormat=function(e){return"intl.datetimeformat"===t.typeOf(e)},exports.isIntlDisplayNames=function(e){return"intl.displaynames"===t.typeOf(e)},exports.isIntlListFormat=function(e){return"intl.listformat"===t.typeOf(e)},exports.isIntlLocale=function(e){return"intl.locale"===t.typeOf(e)},exports.isIntlNumberFormat=function(e){return"intl.numberformat"===t.typeOf(e)};

package/cjs/isArray.js

@@ -0,0 +1 @@
+"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)};

package/cjs/isBoolean.js

@@ -0,0 +1 @@
+"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};

package/cjs/isFunction.js

@@ -0,0 +1 @@
+"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)};

package/cjs/isNull.js

@@ -0,0 +1 @@
+"use strict";exports.isNull=function(n){return null===n},exports.isUndefined=function(n){return void 0===n};

package/cjs/isNumber.js

@@ -0,0 +1 @@
+"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};

package/cjs/isObject.js

@@ -0,0 +1 @@
+"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)};

package/cjs/isString.js

@@ -0,0 +1 @@
+"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;

package/cjs/isSymbol.js

@@ -0,0 +1 @@
+"use strict";var e=require("./typeOf.js");exports.isSymbol=function(r){return"symbol"===e.typeOf(r)};

package/cjs/isType.js

@@ -0,0 +1 @@
+"use strict";exports.isType=function(t,e){return void 0===e||("function"==typeof e?e(t):e)};

package/cjs/typeOf.js

@@ -0,0 +1 @@
+"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"};

package/es/error.js

@@ -0,0 +1 @@
+import{typeOf as r}from"./typeOf.js";function e(e){return"error"===r(e)}function n(e){return"evalerror"===r(e)}function t(e){return"rangeerror"===r(e)}function o(e){return"referenceerror"===r(e)}function u(e){return"syntaxerror"===r(e)}function f(e){return"typeerror"===r(e)}function i(e){return"urierror"===r(e)}function c(e){return"aggregateerror"===r(e)}export{c as isAggregateError,e as isError,n as isEvalError,t as isRangeError,o as isReferenceError,u as isSyntaxError,f as isTypeError,i as isURIError};

package/es/index.js

@@ -0,0 +1 @@
+export{typeOf}from"./typeOf.js";export{isBusinessEmptyString,isEmptyString,isRegExp,isString}from"./isString.js";export{isBigInt,isNaN,isNegativeInteger,isNumber,isPositiveInteger,isZero}from"./isNumber.js";export{isBoolean,isFalse,isTrue}from"./isBoolean.js";export{isNull,isUndefined}from"./isNull.js";export{isAsyncFunction,isFunction,isGenerator,isGeneratorFunction,isPromise}from"./isFunction.js";export{isArray,isArrayBuffer,isBigInt64Array,isBigUint64Array,isEmptyArray,isFloat32Array,isFloat64Array,isInt16Array,isInt8Array,isSet,isSharedArrayBuffer,isUint16Array,isUint32Array,isUint8Array,isUint8ClampedArray,isWeakSet}from"./isArray.js";export{isDataView,isDate,isEmptyObject,isMap,isPlainObject,isWeakMap}from"./isObject.js";export{isSymbol}from"./isSymbol.js";export{isIntlCollator,isIntlDateTimeFormat,isIntlDisplayNames,isIntlListFormat,isIntlLocale,isIntlNumberFormat}from"./intl.js";export{isAggregateError,isError,isEvalError,isRangeError,isReferenceError,isSyntaxError,isTypeError,isURIError}from"./error.js";export{isType}from"./isType.js";

package/es/intl.js

@@ -0,0 +1 @@
+import{typeOf as t}from"./typeOf.js";function n(n){return"intl.collator"===t(n)}function r(n){return"intl.datetimeformat"===t(n)}function i(n){return"intl.displaynames"===t(n)}function o(n){return"intl.listformat"===t(n)}function e(n){return"intl.locale"===t(n)}function u(n){return"intl.numberformat"===t(n)}export{n as isIntlCollator,r as isIntlDateTimeFormat,i as isIntlDisplayNames,o as isIntlListFormat,e as isIntlLocale,u as isIntlNumberFormat};

package/es/isArray.js

@@ -0,0 +1 @@
+import{typeOf as r}from"./typeOf.js";function n(r){return Array.isArray(r)}function t(r){if(n(r))return 0===r.length;throw new TypeError("参数必须为数组")}function u(n){return"set"===r(n)}function a(n){return"weakset"===r(n)}function i(n){return"bigint64array"===r(n)}function e(n){return"biguint64array"===r(n)}function f(n){return"arraybuffer"===r(n)}function o(n){return"int8array"===r(n)}function c(n){return"uint8array"===r(n)}function y(n){return"int16array"===r(n)}function p(n){return"uint16array"===r(n)}function s(n){return"uint32array"===r(n)}function b(n){return"float32array"===r(n)}function l(n){return"float64array"===r(n)}function g(n){return"sharedarraybuffer"===r(n)}function h(n){return"uint8clampedarray"===r(n)}export{n as isArray,f as isArrayBuffer,i as isBigInt64Array,e as isBigUint64Array,t as isEmptyArray,b as isFloat32Array,l as isFloat64Array,y as isInt16Array,o as isInt8Array,u as isSet,g as isSharedArrayBuffer,p as isUint16Array,s as isUint32Array,c as isUint8Array,h as isUint8ClampedArray,a as isWeakSet};

package/es/isBoolean.js

@@ -0,0 +1 @@
+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};

package/es/isFunction.js

@@ -0,0 +1 @@
+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};

package/es/isNull.js

@@ -0,0 +1 @@
+function n(n){return null===n}function r(n){return void 0===n}export{n as isNull,r as isUndefined};

package/es/isNumber.js

@@ -0,0 +1 @@
+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};

package/es/isObject.js

@@ -0,0 +1 @@
+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};

package/es/isString.js

@@ -0,0 +1 @@
+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};

package/es/isSymbol.js

@@ -0,0 +1 @@
+import{typeOf as o}from"./typeOf.js";function r(r){return"symbol"===o(r)}export{r as isSymbol};

package/es/isType.js

@@ -0,0 +1 @@
+function n(n,o){return void 0===o||("function"==typeof o?o(n):o)}export{n as isType};

package/es/typeOf.js

@@ -0,0 +1 @@
+function r(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"}export{r as typeOf};

package/es/types/error.d.ts

@@ -0,0 +1,179 @@
+/**
+ * # 检测 `input` 是否是 `Error` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Error` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isError } from '@mudbean/is';
+ *
+ * console.log(isError(new Error('test'))); // true
+ *
+ * // false (类型不符)
+ * console.log(isError(new EvalError('test')));
+ * // false  (类型不符)
+ * console.log(isError(new RangeError('test')));
+ * // false (类型不符)
+ * console.log(isError(new ReferenceError('test')));
+ *
+ * // false (类型不符)
+ * console.log(isError({ message: 'test' }));
+ * ```
+ * @since 0.1.4
+ */
+export declare function isError(input: any): input is Error;
+/**
+ * # 检测 `input` 是否是 `EvalError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `EvalError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isEvalError } from '@mudbean/is';
+ *
+ * console.log(isEvalError(new EvalError('test'))); // true
+ *
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new Error('test')));
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new TypeError('test')));
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new RangeError('test')));
+ *
+ * // false (类型非 EvalError)
+ * console.log(isEvalError({ message: 'test' }));
+ * ```
+ */
+export declare function isEvalError(input: any): input is EvalError;
+/**
+ * # 检测 `input 是否是 `RangeError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `RangeError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isRangeError } from '@mudbean/is';
+ *
+ * console.log(isRangeError(new RangeError('test'))); // true
+ *
+ * // false (类型非 RangeError
+ * console.log(isRangeError(new Error('test')));
+ * // false (类型非 RangeError)
+ * console.log(isRangeError(new TypeError('test')));
+ * // false (类型非 RangeError)
+ * console.log(isRangeError(new SyntaxError('test')));
+ *
+ * // false (类型非 RangeError)
+ * console.log(isRangeError('test'));
+ * ```
+ */
+export declare function isRangeError(input: any): input is RangeError;
+/**
+ * # 检测 `input` 是否是 `ReferenceError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isReferenceError } from '@mudbean/is';
+ *
+ * console.log(isReferenceError(new ReferenceError('test'))); // true
+ *
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new Error('test')));
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new TypeError('test')));
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new SyntaxError('test')));
+ *
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError('test');
+ * ```
+ */
+export declare function isReferenceError(input: any): input is ReferenceError;
+/**
+ * # 检测 `input` 是否是 `SyntaxError` 类型
+ *
+ *  @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `SyntaxError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isSyntaxError } from '@mudbean/is';
+ *
+ * console.log(isSyntaxError(new SyntaxError('test'))); // true
+ *
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new Error('test')));
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new TypeError('test')));
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new ReferenceError('test')));
+ *
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError('test'));
+ * ```
+ */
+export declare function isSyntaxError(input: any): input is SyntaxError;
+/**
+ * # 检测 `input` 是否是 `TypeError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `TypeError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isTypeError } from '@mudbean/is';
+ *
+ * console.log(isTypeError(new TypeError('test'))); // true
+ *
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new Error('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new SyntaxError('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new ReferenceError('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new EvalError('test')));
+ *
+ * // false (类型非 TypeError)
+ * console.log(isTypeError('test');
+ * ```
+ */
+export declare function isTypeError(input: any): input is TypeError;
+/**
+ * # 检测 `input` 是否是 `URIError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `URIError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isURIError } from '@mudbean/is';
+ *
+ * console.log(isURIError(new URIError('test'))); // true
+ *
+ * console.log(isURIError(new Error('test'))); // false
+ * ```
+ */
+export declare function isURIError(input: any): input is URIError;
+/**
+ * # 检测 `input` 是否是 `AggregateError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `AggregateError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isAggregateError } from '@mudbean/is';
+ *
+ * console.log(isAggregateError(new AggregateError([]))); // true
+ *
+ * console.log(isAggregateError(new Error('test'))); // false
+ * ```
+ */
+export declare function isAggregateError(input: any): input is AggregateError;

package/es/types/index.d.ts

@@ -0,0 +1,13 @@
+export { typeOf } from './typeOf';
+export type { Typeof } from './types';
+export { isString, isRegExp, isEmptyString, isBusinessEmptyString, } from './isString';
+export { isNumber, isNaN, isBigInt, isZero, isNegativeInteger, isPositiveInteger, } from './isNumber';
+export { isBoolean, isTrue, isFalse } from './isBoolean';
+export { isNull, isUndefined } from './isNull';
+export { isFunction, isPromise, isAsyncFunction, isGenerator, isGeneratorFunction, } from './isFunction';
+export { isArray, isEmptyArray, isSet, isWeakSet, isBigInt64Array, isBigUint64Array, isArrayBuffer, isFloat32Array, isFloat64Array, isInt16Array, isInt8Array, isUint16Array, isUint32Array, isUint8Array, isSharedArrayBuffer, isUint8ClampedArray, } from './isArray';
+export { isPlainObject, isEmptyObject, isDate, isDataView, isMap, isWeakMap, } from './isObject';
+export { isSymbol } from './isSymbol';
+export { isIntlCollator, isIntlDateTimeFormat, isIntlDisplayNames, isIntlListFormat, isIntlLocale, isIntlNumberFormat, } from './intl';
+export { isError, isEvalError, isRangeError, isReferenceError, isSyntaxError, isTypeError, isURIError, isAggregateError, } from './error';
+export { isType } from './isType';