@antsoo-lib/utils 0.0.1 → 0.1.1

package/dist/index.cjs

@@ -45,11 +45,87 @@ __export(index_exports, {
   computeTaxRateFn: () => computeTaxRateFn,
   computeWeightFn: () => computeWeightFn,
   divideFn: () => divideFn,
+  env: () => env,
   formatNumber: () => formatNumber,
+  generateUniqueId: () => generateUniqueId,
   getCookie: () => getCookie,
   hasCookie: () => hasCookie,
+  isArguments: () => isArguments,
+  isArray: () => isArray,
+  isArrayBuffer: () => isArrayBuffer,
+  isArrayIndex: () => isArrayIndex,
+  isArrayIterator: () => isArrayIterator,
+  isArrayLike: () => isArrayLike,
+  isArrayLikeObject: () => isArrayLikeObject,
+  isAsyncFunction: () => isAsyncFunction,
+  isAsyncIterable: () => isAsyncIterable,
+  isBase64: () => isBase64,
+  isBigInt: () => isBigInt,
+  isBlob: () => isBlob,
+  isBoolean: () => isBoolean,
+  isBrowser: () => isBrowser,
+  isChineseIDCard: () => isChineseIDCard,
+  isChinesePhone: () => isChinesePhone,
+  isChinesePostalCode: () => isChinesePostalCode,
+  isDate: () => isDate,
+  isDateString: () => isDateString,
+  isDateTimeString: () => isDateTimeString,
+  isDocument: () => isDocument,
+  isElement: () => isElement,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isError: () => isError,
+  isEvent: () => isEvent,
+  isFile: () => isFile,
+  isFinite: () => isFinite,
+  isFormData: () => isFormData,
+  isFunction: () => isFunction,
+  isGeneratorFunction: () => isGeneratorFunction,
+  isHSLColor: () => isHSLColor,
+  isHTMLString: () => isHTMLString,
+  isHexColor: () => isHexColor,
+  isInteger: () => isInteger,
+  isIterable: () => isIterable,
+  isIterator: () => isIterator,
+  isJSONSerializable: () => isJSONSerializable,
+  isJSONString: () => isJSONString,
+  isLength: () => isLength,
+  isMap: () => isMap,
+  isMapIterator: () => isMapIterator,
+  isMatch: () => isMatch,
+  isNaN: () => isNaN,
+  isNative: () => isNative,
+  isNil: () => isNil,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isPlainObject: () => isPlainObject,
+  isPrimitive: () => isPrimitive,
+  isPromise: () => isPromise,
+  isRGBColor: () => isRGBColor,
+  isRegExp: () => isRegExp,
+  isRegExpString: () => isRegExpString,
+  isSafeInteger: () => isSafeInteger,
   isSameOrAfterDay: () => isSameOrAfterDay,
   isSameOrBeforeDay: () => isSameOrBeforeDay,
+  isSet: () => isSet,
+  isSetIterator: () => isSetIterator,
+  isString: () => isString,
+  isStringIterator: () => isStringIterator,
+  isSymbol: () => isSymbol,
+  isTimeString: () => isTimeString,
+  isTimezone: () => isTimezone,
+  isTypedArray: () => isTypedArray,
+  isURL: () => isURL,
+  isURLSearchParams: () => isURLSearchParams,
+  isURLString: () => isURLString,
+  isUndefined: () => isUndefined,
+  isWeakMap: () => isWeakMap,
+  isWeakSet: () => isWeakSet,
+  isWindow: () => isWindow,
+  isXMLString: () => isXMLString,
   multiplyFn: () => multiplyFn,
   removeCookie: () => removeCookie,
   setCookie: () => setCookie,
@@ -69,73 +145,321 @@ function isSameOrBeforeDay(date, day) {
 }
 
 // src/math.ts
-var import_lodash_es = require("lodash-es");
 var import_mathjs = require("mathjs");
+
+// src/is.ts
+var import_lodash_es = require("lodash-es");
+var getTag = (value) => {
+  return Object.prototype.toString.call(value);
+};
+var isArray = import_lodash_es.isArray;
+var isArrayBuffer = import_lodash_es.isArrayBuffer;
+function isAsyncFunction(value) {
+  return getTag(value) === "[object AsyncFunction]" || typeof value === "function" && value.constructor.name === "AsyncFunction";
+}
+function isBigInt(value) {
+  return typeof value === "bigint" || getTag(value) === "[object BigInt]";
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+var isBoolean = import_lodash_es.isBoolean;
+var isArrayLike = import_lodash_es.isArrayLike;
+var isArrayLikeObject = import_lodash_es.isArrayLikeObject;
+var isArguments = import_lodash_es.isArguments;
+var isDate = import_lodash_es.isDate;
+var isElement = import_lodash_es.isElement;
+var isEmpty = import_lodash_es.isEmpty;
+var isEqual = import_lodash_es.isEqual;
+var isError = import_lodash_es.isError;
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var isFunction = import_lodash_es.isFunction;
+function isGeneratorFunction(value) {
+  return getTag(value) === "[object GeneratorFunction]" || typeof value === "function" && value.constructor.name === "GeneratorFunction";
+}
+var isInteger = import_lodash_es.isInteger;
+var isFinite = import_lodash_es.isFinite;
+var isLength = import_lodash_es.isLength;
+var isMap = import_lodash_es.isMap;
+var isNaN = import_lodash_es.isNaN;
+var isNil = import_lodash_es.isNil;
+var isNull = import_lodash_es.isNull;
+var isNumber = import_lodash_es.isNumber;
+var isObject = import_lodash_es.isObject;
+var isObjectLike = import_lodash_es.isObjectLike;
+var isPlainObject = import_lodash_es.isPlainObject;
+var isMatch = import_lodash_es.isMatch;
+var isNative = import_lodash_es.isNative;
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isPromise(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+var isRegExp = import_lodash_es.isRegExp;
+var isSafeInteger = import_lodash_es.isSafeInteger;
+var isSet = import_lodash_es.isSet;
+var isString = import_lodash_es.isString;
+var isSymbol = import_lodash_es.isSymbol;
+var isTypedArray = import_lodash_es.isTypedArray;
+var isUndefined = import_lodash_es.isUndefined;
+function isURL(value) {
+  return typeof URL !== "undefined" && value instanceof URL;
+}
+function isURLSearchParams(value) {
+  return typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams;
+}
+var isWeakMap = import_lodash_es.isWeakMap;
+var isWeakSet = import_lodash_es.isWeakSet;
+function isWindow(value) {
+  return isBrowser() && value === window;
+}
+function isDocument(value) {
+  return isBrowser() && value === document;
+}
+function isEvent(value) {
+  return isBrowser() && value instanceof Event;
+}
+function isPrimitive(value) {
+  return isString(value) || isNumber(value) || isBoolean(value) || isSymbol(value) || isBigInt(value) || isNull(value) || isUndefined(value);
+}
+function isIterable(value) {
+  return value != null && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncIterable(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+function isIterator(value) {
+  return value != null && typeof value.next === "function";
+}
+function isArrayIterator(value) {
+  return getTag(value) === "[object Array Iterator]";
+}
+function isMapIterator(value) {
+  return getTag(value) === "[object Map Iterator]";
+}
+function isSetIterator(value) {
+  return getTag(value) === "[object Set Iterator]";
+}
+function isStringIterator(value) {
+  return getTag(value) === "[object String Iterator]";
+}
+function isJSONSerializable(value) {
+  if (isPrimitive(value)) {
+    return !isUndefined(value);
+  }
+  if (isArray(value)) {
+    return value.every(isJSONSerializable);
+  }
+  if (isPlainObject(value)) {
+    return Object.values(value).every(isJSONSerializable);
+  }
+  return false;
+}
+function isArrayIndex(value) {
+  if (!isNumber(value) && !isString(value)) {
+    return false;
+  }
+  const num = Number(value);
+  return isInteger(num) && num >= 0 && num < Number.MAX_SAFE_INTEGER && String(num) === String(value);
+}
+function isEmail(value) {
+  if (!isString(value)) return false;
+  const emailRegex = /^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+function isURLString(value) {
+  if (!isString(value)) return false;
+  try {
+    const _ = new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isChinesePhone(value) {
+  if (!isString(value)) return false;
+  const phoneRegex = /^1[3-9]\d{9}$/;
+  return phoneRegex.test(value);
+}
+function isChineseIDCard(value) {
+  if (!isString(value)) return false;
+  const idCardRegex = /^[1-9]\d{5}(?:18|19|20)\d{2}(?:0[1-9]|1[0-2])(?:[0-2][1-9]|10|20|30|31)\d{3}[0-9X]$/i;
+  if (!idCardRegex.test(value)) return false;
+  const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+  const checkCodes = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+  let sum = 0;
+  for (let i = 0; i < 17; i++) {
+    sum += Number.parseInt(value[i]) * weights[i];
+  }
+  const checkCode = checkCodes[sum % 11];
+  return checkCode === value[17].toUpperCase();
+}
+function isChinesePostalCode(value) {
+  if (!isString(value)) return false;
+  const postalCodeRegex = /^[1-9]\d{5}$/;
+  return postalCodeRegex.test(value);
+}
+function isJSONString(value) {
+  if (!isString(value)) return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isBase64(value) {
+  if (!isString(value)) return false;
+  const base64Regex = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
+  return base64Regex.test(value);
+}
+function isHexColor(value) {
+  if (!isString(value)) return false;
+  const hexColorRegex = /^#?[a-f0-9]{6}$|^#?[a-f0-9]{3}$/i;
+  return hexColorRegex.test(value);
+}
+function isRGBColor(value) {
+  if (!isString(value)) return false;
+  const rgbColorRegex = /^rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\)$/;
+  return rgbColorRegex.test(value);
+}
+function isHSLColor(value) {
+  if (!isString(value)) return false;
+  const hslColorRegex = /^hsl\(\s*\d{1,3}\s*,\s*\d{1,3}%\s*,\s*\d{1,3}%\s*\)$/;
+  return hslColorRegex.test(value);
+}
+function isDateString(value) {
+  if (!isString(value)) return false;
+  const date = new Date(value);
+  return !isNaN(date.getTime());
+}
+function isTimeString(value) {
+  if (!isString(value)) return false;
+  const timeRegex = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
+  return timeRegex.test(value);
+}
+function isDateTimeString(value) {
+  if (!isString(value)) return false;
+  const dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
+  return dateTimeRegex.test(value) && !isNaN(new Date(value).getTime());
+}
+function isTimezone(value) {
+  if (!isString(value)) return false;
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRegExpString(value) {
+  if (!isString(value)) return false;
+  try {
+    const _ = new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isXMLString(value) {
+  if (!isString(value)) return false;
+  try {
+    if (isBrowser()) {
+      const parser = new DOMParser();
+      const xmlDoc = parser.parseFromString(value, "application/xml");
+      return xmlDoc.getElementsByTagName("parsererror").length === 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function isHTMLString(value) {
+  if (!isString(value)) return false;
+  try {
+    if (isBrowser()) {
+      const parser = new DOMParser();
+      const htmlDoc = parser.parseFromString(value, "text/html");
+      return htmlDoc.body.children.length > 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/math.ts
 var computeTaxAmountFn = (weight, price) => {
-  if (!(0, import_lodash_es.isFinite)(price) || !(0, import_lodash_es.isFinite)(weight)) return 0;
+  if (!isFinite(price) || !isFinite(weight)) return 0;
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const priceBig = (0, import_mathjs.bignumber)(price);
   const value = Number((0, import_mathjs.multiply)(weightBig, priceBig));
   return value;
 };
 var computeTaxAmount2Fn = (weight, price) => {
-  if (!(0, import_lodash_es.isFinite)(price) || !(0, import_lodash_es.isFinite)(weight)) return 0;
+  if (!isFinite(price) || !isFinite(weight)) return 0;
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const priceBig = (0, import_mathjs.bignumber)(price);
   const value = Number((0, import_mathjs.multiply)(weightBig, priceBig));
   return value;
 };
 var computePriceFn = (taxAmount, weight) => {
-  if (!(0, import_lodash_es.isFinite)(taxAmount) || !(0, import_lodash_es.isFinite)(weight) || weight <= 0) return 0;
+  if (!isFinite(taxAmount) || !isFinite(weight) || weight <= 0) return 0;
   const taxAmountBig = (0, import_mathjs.bignumber)(taxAmount);
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const value = Number((0, import_mathjs.divide)(taxAmountBig, weightBig));
   return value;
 };
 var computeWeightFn = (taxAmount, price) => {
-  if (!(0, import_lodash_es.isFinite)(taxAmount) || !(0, import_lodash_es.isFinite)(price) || price <= 0) return 0;
+  if (!isFinite(taxAmount) || !isFinite(price) || price <= 0) return 0;
   const taxAmountBig = (0, import_mathjs.bignumber)(taxAmount);
   const priceBig = (0, import_mathjs.bignumber)(price);
   const value = Number((0, import_mathjs.divide)(taxAmountBig, priceBig));
   return value;
 };
 var computePrice2Fn = (noTaxPrice, taxRate) => {
-  if (!(0, import_lodash_es.isFinite)(noTaxPrice) || !(0, import_lodash_es.isFinite)(taxRate)) return 0;
+  if (!isFinite(noTaxPrice) || !isFinite(taxRate)) return 0;
   const noTaxPriceBig = (0, import_mathjs.bignumber)(noTaxPrice);
   const taxRateBig = (0, import_mathjs.divide)(taxRate, 100);
   const value = Number((0, import_mathjs.multiply)(noTaxPriceBig, (0, import_mathjs.add)(1, taxRateBig)));
   return value;
 };
 var computeNoTaxPriceFn = (price, taxRate) => {
-  if (!(0, import_lodash_es.isFinite)(price) || !(0, import_lodash_es.isFinite)(taxRate)) return 0;
+  if (!isFinite(price) || !isFinite(taxRate)) return 0;
   const priceBig = (0, import_mathjs.bignumber)(price);
   const taxRateBig = (0, import_mathjs.divide)(taxRate, 100);
   const value = Number((0, import_mathjs.divide)(priceBig, (0, import_mathjs.add)(1, taxRateBig)));
   return value;
 };
 var computeTaxRateFn = (price, noTaxPrice) => {
-  if (!(0, import_lodash_es.isFinite)(price) || !(0, import_lodash_es.isFinite)(noTaxPrice)) return 0;
+  if (!isFinite(price) || !isFinite(noTaxPrice)) return 0;
   const priceBig = (0, import_mathjs.bignumber)(price);
   const noTaxPriceBig = (0, import_mathjs.bignumber)(noTaxPrice);
   const value = Number((0, import_mathjs.subtract)((0, import_mathjs.divide)(priceBig, noTaxPriceBig), 1));
   return value;
 };
 var computeNoTaxPrice2Fn = (noTaxAmount, weight) => {
-  if (!(0, import_lodash_es.isFinite)(noTaxAmount) || !(0, import_lodash_es.isFinite)(weight) || weight <= 0) return 0;
+  if (!isFinite(noTaxAmount) || !isFinite(weight) || weight <= 0) return 0;
   const noTaxAmountBig = (0, import_mathjs.bignumber)(noTaxAmount);
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const value = Number((0, import_mathjs.divide)(noTaxAmountBig, weightBig));
   return value;
 };
 var computeNoTaxAmountFn = (weight, noTaxPrice) => {
-  if (!(0, import_lodash_es.isFinite)(noTaxPrice) || !(0, import_lodash_es.isFinite)(weight)) return 0;
+  if (!isFinite(noTaxPrice) || !isFinite(weight)) return 0;
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const noTaxPriceBig = (0, import_mathjs.bignumber)(noTaxPrice);
   const value = Number((0, import_mathjs.multiply)(weightBig, noTaxPriceBig));
   return value;
 };
 var computeNoTaxAmount2Fn = (taxAmount, taxRate) => {
-  if (!(0, import_lodash_es.isFinite)(taxAmount) || !(0, import_lodash_es.isFinite)(taxRate)) return 0;
+  if (!isFinite(taxAmount) || !isFinite(taxRate)) return 0;
   const taxAmountBig = (0, import_mathjs.bignumber)(taxAmount);
   const taxRateBig = (0, import_mathjs.divide)(taxRate, 100);
   const value = Number((0, import_mathjs.divide)(taxAmountBig, (0, import_mathjs.add)(1, taxRateBig)));
@@ -148,21 +472,21 @@ var computeTaxFn = (taxAmount, noTaxAmount) => {
   return value;
 };
 var computeGoodsNumFn = (weight, weight1) => {
-  if (!(0, import_lodash_es.isFinite)(weight1) || !(0, import_lodash_es.isFinite)(weight) || weight1 <= 0) return 0;
+  if (!isFinite(weight1) || !isFinite(weight) || weight1 <= 0) return 0;
   const weightBig = (0, import_mathjs.bignumber)(weight);
   const weight1Big = (0, import_mathjs.bignumber)(weight1);
   const value = Number((0, import_mathjs.divide)(weightBig, weight1Big));
   return value;
 };
 var computeGoodsWeightFn = (num, weight1) => {
-  if (!(0, import_lodash_es.isFinite)(weight1) || !(0, import_lodash_es.isFinite)(num) || weight1 <= 0) return 0;
+  if (!isFinite(weight1) || !isFinite(num) || weight1 <= 0) return 0;
   const numBig = (0, import_mathjs.bignumber)(num);
   const weight1Big = (0, import_mathjs.bignumber)(weight1);
   const value = Number((0, import_mathjs.multiply)(numBig, weight1Big));
   return value;
 };
 var addFn = (a, b) => {
-  if (!(0, import_lodash_es.isFinite)(a) || !(0, import_lodash_es.isFinite)(b)) return 0;
+  if (!isFinite(a) || !isFinite(b)) return 0;
   const aBig = (0, import_mathjs.bignumber)(a);
   const bBig = (0, import_mathjs.bignumber)(b);
   return Number((0, import_mathjs.add)(aBig, bBig));
@@ -171,19 +495,19 @@ function sumBy(arr, key) {
   return arr.reduce((acc, cur) => addFn(acc, Number(cur[key])), 0);
 }
 var subtractFn = (a, b) => {
-  if (!(0, import_lodash_es.isFinite)(a) || !(0, import_lodash_es.isFinite)(b)) return 0;
+  if (!isFinite(a) || !isFinite(b)) return 0;
   const aBig = (0, import_mathjs.bignumber)(a);
   const bBig = (0, import_mathjs.bignumber)(b);
   return Number((0, import_mathjs.subtract)(aBig, bBig));
 };
 var multiplyFn = (a, b) => {
-  if (!(0, import_lodash_es.isFinite)(a) || !(0, import_lodash_es.isFinite)(b)) return 0;
+  if (!isFinite(a) || !isFinite(b)) return 0;
   const aBig = (0, import_mathjs.bignumber)(a);
   const bBig = (0, import_mathjs.bignumber)(b);
   return Number((0, import_mathjs.multiply)(aBig, bBig));
 };
 var divideFn = (a, b) => {
-  if (!(0, import_lodash_es.isFinite)(a) || !(0, import_lodash_es.isFinite)(b) || b === 0) return 0;
+  if (!isFinite(a) || !isFinite(b) || b === 0) return 0;
   const aBig = (0, import_mathjs.bignumber)(a);
   const bBig = (0, import_mathjs.bignumber)(b);
   return Number((0, import_mathjs.divide)(aBig, bBig));
@@ -254,6 +578,27 @@ function removeCookie(name, path = "/", domain) {
 function hasCookie(name) {
   return getCookie(name) !== null;
 }
+
+// src/function.ts
+function generateUniqueId(prefix) {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${prefix || ""}${timestamp}_${random}`;
+}
+
+// src/env.ts
+function env(appEnv) {
+  const isDev = appEnv === "development";
+  const isTest = appEnv === "test";
+  const isPre = appEnv === "pre-release";
+  const isProd = appEnv === "production";
+  return {
+    isDev,
+    isTest,
+    isPre,
+    isProd
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addFn,
@@ -271,11 +616,87 @@ function hasCookie(name) {
   computeTaxRateFn,
   computeWeightFn,
   divideFn,
+  env,
   formatNumber,
+  generateUniqueId,
   getCookie,
   hasCookie,
+  isArguments,
+  isArray,
+  isArrayBuffer,
+  isArrayIndex,
+  isArrayIterator,
+  isArrayLike,
+  isArrayLikeObject,
+  isAsyncFunction,
+  isAsyncIterable,
+  isBase64,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isBrowser,
+  isChineseIDCard,
+  isChinesePhone,
+  isChinesePostalCode,
+  isDate,
+  isDateString,
+  isDateTimeString,
+  isDocument,
+  isElement,
+  isEmail,
+  isEmpty,
+  isEqual,
+  isError,
+  isEvent,
+  isFile,
+  isFinite,
+  isFormData,
+  isFunction,
+  isGeneratorFunction,
+  isHSLColor,
+  isHTMLString,
+  isHexColor,
+  isInteger,
+  isIterable,
+  isIterator,
+  isJSONSerializable,
+  isJSONString,
+  isLength,
+  isMap,
+  isMapIterator,
+  isMatch,
+  isNaN,
+  isNative,
+  isNil,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isPlainObject,
+  isPrimitive,
+  isPromise,
+  isRGBColor,
+  isRegExp,
+  isRegExpString,
+  isSafeInteger,
   isSameOrAfterDay,
   isSameOrBeforeDay,
+  isSet,
+  isSetIterator,
+  isString,
+  isStringIterator,
+  isSymbol,
+  isTimeString,
+  isTimezone,
+  isTypedArray,
+  isURL,
+  isURLSearchParams,
+  isURLString,
+  isUndefined,
+  isWeakMap,
+  isWeakSet,
+  isWindow,
+  isXMLString,
   multiplyFn,
   removeCookie,
   setCookie,