@odinlin/utils 0.0.2 → 1.0.0

package/dist/browser/is/index.cjs

@@ -0,0 +1,42 @@
+const require_isTypeOf = require('./isTypeOf.cjs');
+const require_isPrimitive = require('./isPrimitive.cjs');
+const require_isJSON = require('./isJSON.cjs');
+const require_isPlatform = require('./isPlatform.cjs');
+const require_isPrimitiveWithout = require('./isPrimitiveWithout.cjs');
+const require_isTagOf = require('./isTagOf.cjs');
+
+exports.isArray = require_isPrimitiveWithout.isArray;
+exports.isBigInt = require_isPrimitive.isBigInt;
+exports.isBoolean = require_isPrimitive.isBoolean;
+exports.isBooleanLike = require_isPrimitive.isBooleanLike;
+exports.isBrowser = require_isPlatform.isBrowser;
+exports.isDate = require_isPrimitiveWithout.isDate;
+exports.isEmpty = require_isPrimitiveWithout.isEmpty;
+exports.isError = require_isPrimitiveWithout.isError;
+exports.isFunction = require_isPrimitiveWithout.isFunction;
+exports.isJSONArray = require_isJSON.isJSONArray;
+exports.isJSONObject = require_isJSON.isJSONObject;
+exports.isJSONString = require_isJSON.isJSONString;
+exports.isJSONValue = require_isJSON.isJSONValue;
+exports.isMap = require_isPrimitiveWithout.isMap;
+exports.isNil = require_isPrimitive.isNil;
+exports.isNode = require_isPlatform.isNode;
+exports.isNotNumber = require_isPrimitive.isNotNumber;
+exports.isNull = require_isPrimitive.isNull;
+exports.isNumber = require_isPrimitive.isNumber;
+exports.isNumberLike = require_isPrimitive.isNumberLike;
+exports.isObject = require_isPrimitiveWithout.isObject;
+exports.isPlainObject = require_isPrimitiveWithout.isPlainObject;
+exports.isPrimitive = require_isPrimitive.isPrimitive;
+exports.isPromise = require_isPrimitiveWithout.isPromise;
+exports.isRegExp = require_isPrimitiveWithout.isRegExp;
+exports.isSet = require_isPrimitiveWithout.isSet;
+exports.isString = require_isPrimitive.isString;
+exports.isStringLike = require_isPrimitive.isStringLike;
+exports.isSymbol = require_isPrimitive.isSymbol;
+exports.isTagOf = require_isTagOf.isTagOf;
+exports.isTypeOf = require_isTypeOf.isTypeOf;
+exports.isTypeOfResult = require_isTypeOf.isTypeOfResult;
+exports.isUndefined = require_isPrimitive.isUndefined;
+exports.isWeakMap = require_isPrimitiveWithout.isWeakMap;
+exports.isWeakSet = require_isPrimitiveWithout.isWeakSet;

package/dist/browser/is/index.d.ts

@@ -0,0 +1,7 @@
+import { TypeJSONValue, isJSONArray, isJSONObject, isJSONString, isJSONValue } from "./isJSON.js";
+import { isBrowser, isNode } from "./isPlatform.js";
+import { TypeNil, TypePrimitive, isBigInt, isBoolean, isBooleanLike, isNil, isNotNumber, isNull, isNumber, isNumberLike, isPrimitive, isString, isStringLike, isSymbol, isUndefined } from "./isPrimitive.js";
+import { TypeTypedArray, isArray, isDate, isEmpty, isError, isFunction, isMap, isObject, isPlainObject, isPromise, isRegExp, isSet, isWeakMap, isWeakSet } from "./isPrimitiveWithout.js";
+import { isTagOf } from "./isTagOf.js";
+import { isTypeOf, isTypeOfResult } from "./isTypeOf.js";
+export { TypeJSONValue, TypeNil, TypePrimitive, TypeTypedArray, isArray, isBigInt, isBoolean, isBooleanLike, isBrowser, isDate, isEmpty, isError, isFunction, isJSONArray, isJSONObject, isJSONString, isJSONValue, isMap, isNil, isNode, isNotNumber, isNull, isNumber, isNumberLike, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isStringLike, isSymbol, isTagOf, isTypeOf, isTypeOfResult, isUndefined, isWeakMap, isWeakSet };

package/dist/browser/is/index.js

@@ -0,0 +1,8 @@
+import { isTypeOf, isTypeOfResult } from "./isTypeOf.js";
+import { isBigInt, isBoolean, isBooleanLike, isNil, isNotNumber, isNull, isNumber, isNumberLike, isPrimitive, isString, isStringLike, isSymbol, isUndefined } from "./isPrimitive.js";
+import { isJSONArray, isJSONObject, isJSONString, isJSONValue } from "./isJSON.js";
+import { isBrowser, isNode } from "./isPlatform.js";
+import { isArray, isDate, isEmpty, isError, isFunction, isMap, isObject, isPlainObject, isPromise, isRegExp, isSet, isWeakMap, isWeakSet } from "./isPrimitiveWithout.js";
+import { isTagOf } from "./isTagOf.js";
+
+export { isArray, isBigInt, isBoolean, isBooleanLike, isBrowser, isDate, isEmpty, isError, isFunction, isJSONArray, isJSONObject, isJSONString, isJSONValue, isMap, isNil, isNode, isNotNumber, isNull, isNumber, isNumberLike, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isStringLike, isSymbol, isTagOf, isTypeOf, isTypeOfResult, isUndefined, isWeakMap, isWeakSet };

package/dist/browser/is/isJSON.cjs

@@ -0,0 +1,44 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_isPrimitive = require('./isPrimitive.cjs');
+let es_toolkit = require("es-toolkit");
+
+//#region src/is/isJSON.ts
+/**
+* 判断 json array 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isJSONArray = (x) => (0, es_toolkit.isJSONArray)(x);
+/**
+* 判断 json object 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isJSONObject = (x) => (0, es_toolkit.isJSONObject)(x);
+/**
+* 判断 json 值类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+function isJSONValue(x) {
+	return x === null || require_isPrimitive.isBoolean(x) || require_isPrimitive.isNumber(x) || require_isPrimitive.isString(x);
+}
+/**
+* 判断是否为有效的 json 字符串 (通过尝试序列化是否成功来判断)
+* 🚫 非类型谓词
+* @function override
+* @param {unknown} x 待检测值
+* @returns {[boolean, any]} [错误优先, 可能存在的序列化结果]
+*/
+function isJSONString(x, reviver) {
+	if (!require_isPrimitive.isString(x)) return [/* @__PURE__ */ new TypeError("Not a string"), void 0];
+	try {
+		return [null, JSON.parse(x, reviver)];
+	} catch (e) {
+		return [e, void 0];
+	}
+}
+
+//#endregion
+exports.isJSONArray = isJSONArray;
+exports.isJSONObject = isJSONObject;
+exports.isJSONString = isJSONString;
+exports.isJSONValue = isJSONValue;

package/dist/browser/is/isJSON.d.ts

@@ -0,0 +1,30 @@
+//#region src/is/isJSON.d.ts
+/** 在 json 格式中支持的值类型 */
+type TypeJSONValue = null | boolean | number | string;
+/**
+ * 判断 json array 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isJSONArray: <T extends TypeJSONValue = TypeJSONValue>(x: unknown) => x is Array<T>;
+/**
+ * 判断 json object 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isJSONObject: <T extends TypeJSONValue = TypeJSONValue>(x: unknown) => x is Record<string, T>;
+/**
+ * 判断 json 值类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare function isJSONValue<T extends TypeJSONValue = TypeJSONValue>(x: unknown): x is T;
+/**
+ * 判断是否为有效的 json 字符串 (通过尝试序列化是否成功来判断)
+ * 🚫 非类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ * @returns {[boolean, any]} [错误优先, 可能存在的序列化结果]
+ */
+declare function isJSONString<T = any>(x: unknown, reviver?: (this: any, key: string, value: any) => any): [null, T] | [Error, undefined];
+//#endregion
+export { TypeJSONValue, isJSONArray, isJSONObject, isJSONString, isJSONValue };
+//# sourceMappingURL=isJSON.d.ts.map

package/dist/browser/is/isJSON.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isJSON.d.ts","names":[],"sources":["../../../src/is/isJSON.ts"],"sourcesContent":[],"mappings":";;AAOY,KAAA,aAAA,GAAa,IAAA,GAAA,OAAA,GAAA,MAAA,GAAA,MAAA;AAMzB;;;;AAAuF,cAA1E,WAA0E,EAAA,CAAA,UAAjD,aAAiD,GAAjC,aAAiC,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,KAAA,CAAM,CAAN,CAAA;;AAMvF;;;AAAuG,cAA1F,YAA0F,EAAA,CAAA,UAAhE,aAAgE,GAAhD,aAAgD,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAf,MAAe,CAAA,MAAA,EAAA,CAAA,CAAA;;;AAOvG;;;AAAuF,iBAAvE,WAAuE,CAAA,UAAjD,aAAiD,GAAjC,aAAiC,CAAA,CAAA,CAAA,EAAA,OAAA,CAAA,EAAA,CAAA,IAAA,CAAA;;AAWvF;;;;;;iBAAgB,iGAAiG,MAAM"}

package/dist/browser/is/isJSON.js

@@ -0,0 +1,41 @@
+import { isBoolean as isBoolean$1, isNumber, isString as isString$1 } from "./isPrimitive.js";
+import { isJSONArray, isJSONObject } from "es-toolkit";
+
+//#region src/is/isJSON.ts
+/**
+* 判断 json array 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isJSONArray$1 = (x) => isJSONArray(x);
+/**
+* 判断 json object 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isJSONObject$1 = (x) => isJSONObject(x);
+/**
+* 判断 json 值类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+function isJSONValue(x) {
+	return x === null || isBoolean$1(x) || isNumber(x) || isString$1(x);
+}
+/**
+* 判断是否为有效的 json 字符串 (通过尝试序列化是否成功来判断)
+* 🚫 非类型谓词
+* @function override
+* @param {unknown} x 待检测值
+* @returns {[boolean, any]} [错误优先, 可能存在的序列化结果]
+*/
+function isJSONString(x, reviver) {
+	if (!isString$1(x)) return [/* @__PURE__ */ new TypeError("Not a string"), void 0];
+	try {
+		return [null, JSON.parse(x, reviver)];
+	} catch (e) {
+		return [e, void 0];
+	}
+}
+
+//#endregion
+export { isJSONArray$1 as isJSONArray, isJSONObject$1 as isJSONObject, isJSONString, isJSONValue };
+//# sourceMappingURL=isJSON.js.map

package/dist/browser/is/isJSON.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isJSON.js","names":["isJSONArray","originJSONArray","isJSONObject","originJSONObject","isBoolean","isString","e: any"],"sources":["../../../src/is/isJSON.ts"],"sourcesContent":["import {\n  isJSONArray as originJSONArray,\n  isJSONObject as originJSONObject,\n} from 'es-toolkit'\nimport { isBoolean, isNumber, isString } from './isPrimitive'\n\n/** 在 json 格式中支持的值类型 */\nexport type TypeJSONValue = null | boolean | number | string\n\n/**\n * 判断 json array 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isJSONArray = <T extends TypeJSONValue = TypeJSONValue>(x: unknown): x is Array<T> => originJSONArray(x)\n\n/**\n * 判断 json object 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isJSONObject = <T extends TypeJSONValue = TypeJSONValue>(x: unknown): x is Record<string, T> => originJSONObject(x)\n\n/**\n * 判断 json 值类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport function isJSONValue<T extends TypeJSONValue = TypeJSONValue>(x: unknown): x is T {\n  return x === null || isBoolean(x) || isNumber(x) || isString(x)\n}\n\n/**\n * 判断是否为有效的 json 字符串 (通过尝试序列化是否成功来判断)\n * 🚫 非类型谓词\n * @function override\n * @param {unknown} x 待检测值\n * @returns {[boolean, any]} [错误优先, 可能存在的序列化结果]\n */\nexport function isJSONString<T = any>(x: unknown, reviver?: (this: any, key: string, value: any) => any): [null, T] | [Error, undefined] {\n  if (!isString(x)) return [new TypeError('Not a string'), undefined]\n  try {\n    const value = JSON.parse(x, reviver)\n    return [null, value]\n  }\n  catch (e: any) {\n    return [e, undefined]\n  }\n}\n"],"mappings":";;;;;;;;AAaA,MAAaA,iBAAwD,MAA8BC,YAAgB,EAAE;;;;;AAMrH,MAAaC,kBAAyD,MAAuCC,aAAiB,EAAE;;;;;;AAOhI,SAAgB,YAAqD,GAAoB;AACvF,QAAO,MAAM,QAAQC,YAAU,EAAE,IAAI,SAAS,EAAE,IAAIC,WAAS,EAAE;;;;;;;;;AAUjE,SAAgB,aAAsB,GAAY,SAAuF;AACvI,KAAI,CAACA,WAAS,EAAE,CAAE,QAAO,iBAAC,IAAI,UAAU,eAAe,EAAE,OAAU;AACnE,KAAI;AAEF,SAAO,CAAC,MADM,KAAK,MAAM,GAAG,QAAQ,CAChB;UAEfC,GAAQ;AACb,SAAO,CAAC,GAAG,OAAU"}

package/dist/browser/is/isPlatform.cjs

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let es_toolkit = require("es-toolkit");
+
+//#region src/is/isPlatform.ts
+/**
+* 判断是否是 Node.js 环境
+* 🚫 非类型谓词
+* @returns {boolean} 若当前当前环境是 Node.js 返回 true，否则返回 false
+*/
+const isBrowser = () => (0, es_toolkit.isBrowser)();
+/**
+* 判断是否是 浏览器 环境
+* 🚫 非类型谓词
+* @returns {boolean} 若当前当前环境是浏览器返回 true，否则返回 false
+*/
+const isNode = () => (0, es_toolkit.isNode)();
+
+//#endregion
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;

package/dist/browser/is/isPlatform.d.ts

@@ -0,0 +1,16 @@
+//#region src/is/isPlatform.d.ts
+/**
+ * 判断是否是 Node.js 环境
+ * 🚫 非类型谓词
+ * @returns {boolean} 若当前当前环境是 Node.js 返回 true，否则返回 false
+ */
+declare const isBrowser: () => boolean;
+/**
+ * 判断是否是 浏览器 环境
+ * 🚫 非类型谓词
+ * @returns {boolean} 若当前当前环境是浏览器返回 true，否则返回 false
+ */
+declare const isNode: () => boolean;
+//#endregion
+export { isBrowser, isNode };
+//# sourceMappingURL=isPlatform.d.ts.map

package/dist/browser/is/isPlatform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlatform.d.ts","names":[],"sources":["../../../src/is/isPlatform.ts"],"sourcesContent":[],"mappings":";;AAOA;AAOA;;;cAPa;;;;;;cAOA"}

package/dist/browser/is/isPlatform.js

@@ -0,0 +1,19 @@
+import { isBrowser, isNode } from "es-toolkit";
+
+//#region src/is/isPlatform.ts
+/**
+* 判断是否是 Node.js 环境
+* 🚫 非类型谓词
+* @returns {boolean} 若当前当前环境是 Node.js 返回 true，否则返回 false
+*/
+const isBrowser$1 = () => isBrowser();
+/**
+* 判断是否是 浏览器 环境
+* 🚫 非类型谓词
+* @returns {boolean} 若当前当前环境是浏览器返回 true，否则返回 false
+*/
+const isNode$1 = () => isNode();
+
+//#endregion
+export { isBrowser$1 as isBrowser, isNode$1 as isNode };
+//# sourceMappingURL=isPlatform.js.map

package/dist/browser/is/isPlatform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlatform.js","names":["isBrowser","originBrowser","isNode","originNode"],"sources":["../../../src/is/isPlatform.ts"],"sourcesContent":["import { isBrowser as originBrowser, isNode as originNode } from 'es-toolkit'\n\n/**\n * 判断是否是 Node.js 环境\n * 🚫 非类型谓词\n * @returns {boolean} 若当前当前环境是 Node.js 返回 true，否则返回 false\n */\nexport const isBrowser = (): boolean => originBrowser()\n\n/**\n * 判断是否是 浏览器 环境\n * 🚫 非类型谓词\n * @returns {boolean} 若当前当前环境是浏览器返回 true，否则返回 false\n */\nexport const isNode = (): boolean => originNode()\n"],"mappings":";;;;;;;;AAOA,MAAaA,oBAA2BC,WAAe;;;;;;AAOvD,MAAaC,iBAAwBC,QAAY"}

package/dist/browser/is/isPrimitive.cjs

@@ -0,0 +1,91 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_isTypeOf = require('./isTypeOf.cjs');
+let es_toolkit = require("es-toolkit");
+
+//#region src/is/isPrimitive.ts
+/**
+* 判断 null 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNull = (x) => (0, es_toolkit.isNull)(x);
+/**
+* 判断 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isUndefined = (x) => (0, es_toolkit.isUndefined)(x);
+/**
+* 判断 boolean 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBoolean = (x) => (0, es_toolkit.isBoolean)(x);
+/**
+* 判断 string 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isString = (x) => (0, es_toolkit.isString)(x);
+/**
+* 判断 Symbol 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSymbol = (x) => (0, es_toolkit.isSymbol)(x);
+/**
+* 判断 number 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNumber = (x) => require_isTypeOf.isTypeOf(x, ["number"]);
+/**
+* 判断 bigint 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBigInt = (x) => require_isTypeOf.isTypeOf(x, ["bigint"]);
+/**
+* 判断 null 或 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNil = (x) => (0, es_toolkit.isNil)(x);
+/**
+* 判断 基本数据 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPrimitive = (x) => (0, es_toolkit.isPrimitive)(x);
+/**
+* 判断 boolean + new Boolean(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isBooleanLike = (x) => isBoolean(x) || x instanceof Boolean;
+/**
+* 判断 string + new String(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isStringLike = (x) => isString(x) || x instanceof String;
+/**
+* 判断 number + new Number(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isNumberLike = (x) => isNumber(x) || x instanceof Number;
+/**
+* 判断是否为非数字
+* 🚫 非类型谓词
+* @function override
+* @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+* @param {unknown} x 待检测值
+*/
+const isNotNumber = (x) => Number.isNaN(x);
+
+//#endregion
+exports.isBigInt = isBigInt;
+exports.isBoolean = isBoolean;
+exports.isBooleanLike = isBooleanLike;
+exports.isNil = isNil;
+exports.isNotNumber = isNotNumber;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isNumberLike = isNumberLike;
+exports.isPrimitive = isPrimitive;
+exports.isString = isString;
+exports.isStringLike = isStringLike;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;

package/dist/browser/is/isPrimitive.d.ts

@@ -0,0 +1,79 @@
+//#region src/is/isPrimitive.d.ts
+/** 空值 */
+type TypeNil = null | undefined;
+/** 基本数据类型 */
+type TypePrimitive = null | undefined | boolean | number | bigint | string | symbol;
+/**
+ * 判断 null 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNull: (x: unknown) => x is null;
+/**
+ * 判断 undefined 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isUndefined: (x: unknown) => x is undefined;
+/**
+ * 判断 boolean 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isBoolean: (x: unknown) => x is boolean;
+/**
+ * 判断 string 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isString: (x: unknown) => x is string;
+/**
+ * 判断 Symbol 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isSymbol: (x: unknown) => x is symbol;
+/**
+ * 判断 number 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNumber: (x: unknown) => x is number;
+/**
+ * 判断 bigint 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isBigInt: (x: unknown) => x is bigint;
+/**
+ * 判断 null 或 undefined 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNil: (x: unknown) => x is TypeNil;
+/**
+ * 判断 基本数据 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isPrimitive: (x: unknown) => x is TypePrimitive;
+/**
+ * 判断 boolean + new Boolean(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isBooleanLike: (x: unknown) => x is boolean;
+/**
+ * 判断 string + new String(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isStringLike: (x: unknown) => x is string;
+/**
+ * 判断 number + new Number(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isNumberLike: (x: unknown) => x is number;
+/**
+ * 判断是否为非数字
+ * 🚫 非类型谓词
+ * @function override
+ * @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+ * @param {unknown} x 待检测值
+ */
+declare const isNotNumber: (x: unknown) => boolean;
+//#endregion
+export { TypeNil, TypePrimitive, isBigInt, isBoolean, isBooleanLike, isNil, isNotNumber, isNull, isNumber, isNumberLike, isPrimitive, isString, isStringLike, isSymbol, isUndefined };
+//# sourceMappingURL=isPrimitive.d.ts.map

package/dist/browser/is/isPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitive.d.ts","names":[],"sources":["../../../src/is/isPrimitive.ts"],"sourcesContent":[],"mappings":";;AAgBY,KAAA,OAAA,GAAO,IAAA,GAAA,SAAA;AAEnB;AAMa,KAND,aAAA,GAMkD,IAAA,GAAA,SAAA,GAAA,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,MAAA;AAK9D;AAMA;AAKA;AAKA;AAKa,cA1BA,MA0B+D,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,IAAA;AAK5E;AAMA;AAKA;AAOA;AAMa,cAlDA,WAkDgF,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,SAAA;AAM7F;AAQA;;;cA1Da;;;;;cAKA;;;;;cAKA;;;;;cAKA;;;;;cAKA;;;;;cAMA,4BAA2B;;;;;cAK3B,kCAAiC;;;;;;cAOjC;;;;;;cAMA;;;;;;cAMA;;;;;;;;cAQA"}

package/dist/browser/is/isPrimitive.js

@@ -0,0 +1,79 @@
+import { isTypeOf } from "./isTypeOf.js";
+import { isBoolean, isNil, isNull, isPrimitive, isString, isSymbol, isUndefined } from "es-toolkit";
+
+//#region src/is/isPrimitive.ts
+/**
+* 判断 null 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNull$1 = (x) => isNull(x);
+/**
+* 判断 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isUndefined$1 = (x) => isUndefined(x);
+/**
+* 判断 boolean 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBoolean$1 = (x) => isBoolean(x);
+/**
+* 判断 string 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isString$1 = (x) => isString(x);
+/**
+* 判断 Symbol 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSymbol$1 = (x) => isSymbol(x);
+/**
+* 判断 number 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNumber = (x) => isTypeOf(x, ["number"]);
+/**
+* 判断 bigint 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBigInt = (x) => isTypeOf(x, ["bigint"]);
+/**
+* 判断 null 或 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNil$1 = (x) => isNil(x);
+/**
+* 判断 基本数据 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPrimitive$1 = (x) => isPrimitive(x);
+/**
+* 判断 boolean + new Boolean(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isBooleanLike = (x) => isBoolean$1(x) || x instanceof Boolean;
+/**
+* 判断 string + new String(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isStringLike = (x) => isString$1(x) || x instanceof String;
+/**
+* 判断 number + new Number(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isNumberLike = (x) => isNumber(x) || x instanceof Number;
+/**
+* 判断是否为非数字
+* 🚫 非类型谓词
+* @function override
+* @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+* @param {unknown} x 待检测值
+*/
+const isNotNumber = (x) => Number.isNaN(x);
+
+//#endregion
+export { isBigInt, isBoolean$1 as isBoolean, isBooleanLike, isNil$1 as isNil, isNotNumber, isNull$1 as isNull, isNumber, isNumberLike, isPrimitive$1 as isPrimitive, isString$1 as isString, isStringLike, isSymbol$1 as isSymbol, isUndefined$1 as isUndefined };
+//# sourceMappingURL=isPrimitive.js.map

package/dist/browser/is/isPrimitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitive.js","names":["isNull","originNull","isUndefined","originUndefined","isBoolean","originBoolean","isString","originString","isSymbol","originSymbol","isNil","originNil","isPrimitive","originPrimitive"],"sources":["../../../src/is/isPrimitive.ts"],"sourcesContent":["/* eslint-disable unicorn/no-instanceof-builtins */\n/* eslint-disable perfectionist/sort-named-imports */\nimport {\n  isNull as originNull,\n  isUndefined as originUndefined,\n  isBoolean as originBoolean,\n  // isNumber as originNumber,\n  isString as originString,\n  // isBigInt as originBigInt,\n  isSymbol as originSymbol,\n  isNil as originNil,\n  isPrimitive as originPrimitive,\n} from 'es-toolkit'\nimport { isTypeOf } from './isTypeOf'\n\n/** 空值 */\nexport type TypeNil = null | undefined\n/** 基本数据类型 */\nexport type TypePrimitive = null | undefined | boolean | number | bigint | string | symbol\n\n/**\n * 判断 null 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNull = (x: unknown): x is null => originNull(x)\n/**\n * 判断 undefined 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isUndefined = (x: unknown): x is undefined => originUndefined(x)\n\n/**\n * 判断 boolean 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isBoolean = (x: unknown): x is boolean => originBoolean(x)\n/**\n * 判断 string 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isString = (x: unknown): x is string => originString(x)\n/**\n * 判断 Symbol 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isSymbol = (x: unknown): x is symbol => originSymbol(x)\n/**\n * 判断 number 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNumber = (x: unknown): x is number => isTypeOf(x, ['number'])\n/**\n * 判断 bigint 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isBigInt = (x: unknown): x is bigint => isTypeOf(x, ['bigint'])\n\n/**\n * 判断 null 或 undefined 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNil = (x: unknown): x is TypeNil => originNil(x)\n/**\n * 判断 基本数据 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isPrimitive = (x: unknown): x is TypePrimitive => originPrimitive(x)\n\n/**\n * 判断 boolean + new Boolean(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isBooleanLike = (x: unknown): x is boolean => isBoolean(x) || (x instanceof Boolean)\n/**\n * 判断 string + new String(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isStringLike = (x: unknown): x is string => isString(x) || (x instanceof String)\n/**\n * 判断 number + new Number(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isNumberLike = (x: unknown): x is number => isNumber(x) || (x instanceof Number)\n/**\n * 判断是否为非数字\n * 🚫 非类型谓词\n * @function override\n * @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字\n * @param {unknown} x 待检测值\n */\nexport const isNotNumber = (x: unknown): boolean => Number.isNaN(x)\n"],"mappings":";;;;;;;;AAwBA,MAAaA,YAAU,MAA0BC,OAAW,EAAE;;;;;AAK9D,MAAaC,iBAAe,MAA+BC,YAAgB,EAAE;;;;;AAM7E,MAAaC,eAAa,MAA6BC,UAAc,EAAE;;;;;AAKvE,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAa,YAAY,MAA4B,SAAS,GAAG,CAAC,SAAS,CAAC;;;;;AAK5E,MAAa,YAAY,MAA4B,SAAS,GAAG,CAAC,SAAS,CAAC;;;;;AAM5E,MAAaC,WAAS,MAA6BC,MAAU,EAAE;;;;;AAK/D,MAAaC,iBAAe,MAAmCC,YAAgB,EAAE;;;;;;AAOjF,MAAa,iBAAiB,MAA6BT,YAAU,EAAE,IAAK,aAAa;;;;;;AAMzF,MAAa,gBAAgB,MAA4BE,WAAS,EAAE,IAAK,aAAa;;;;;;AAMtF,MAAa,gBAAgB,MAA4B,SAAS,EAAE,IAAK,aAAa;;;;;;;;AAQtF,MAAa,eAAe,MAAwB,OAAO,MAAM,EAAE"}

package/dist/browser/is/isPrimitiveWithout.cjs

@@ -0,0 +1,86 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let es_toolkit = require("es-toolkit");
+let es_toolkit_compat = require("es-toolkit/compat");
+
+//#region src/is/isPrimitiveWithout.ts
+/**
+* 判断 Array 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isArray = (x) => (0, es_toolkit_compat.isArray)(x);
+/**
+* 判断 Object 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isObject = (x) => (0, es_toolkit_compat.isObject)(x);
+/**
+* 判断 Function 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isFunction = (x) => (0, es_toolkit.isFunction)(x);
+/**
+* 判断 Set 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSet = (x) => (0, es_toolkit.isSet)(x);
+/**
+* 判断 Map 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isMap = (x) => (0, es_toolkit.isMap)(x);
+/**
+* 判断 WeakSet 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakSet = (x) => (0, es_toolkit.isWeakSet)(x);
+/**
+* 判断 WeakMap 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakMap = (x) => (0, es_toolkit.isWeakMap)(x);
+/**
+* 判断 Date 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isDate = (x) => (0, es_toolkit.isDate)(x);
+/**
+* 判断 RegExp 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isRegExp = (x) => (0, es_toolkit.isRegExp)(x);
+/**
+* 判断 Promise 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPromise = (x) => (0, es_toolkit.isPromise)(x);
+/**
+* 判断 Error 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isError = (x) => (0, es_toolkit.isError)(x);
+/**
+* 判断 普通对象 Record<PropertyKey, unknown> 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPlainObject = (x) => (0, es_toolkit.isPlainObject)(x);
+/**
+* 判断 给定值 是否为空
+* 🚫 非类型谓词
+* @returns {boolean} 可以判断字符串、数组、对象、Map、Set 等类型是否为空
+*/
+const isEmpty = (x) => (0, es_toolkit_compat.isEmpty)(x);
+
+//#endregion
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isError = isError;
+exports.isFunction = isFunction;
+exports.isMap = isMap;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;