@fangzhongya/utils 0.0.11 → 0.0.16

package/dist/chunk-P7AWHISY.js

@@ -0,0 +1,15 @@
+// packages/basic/string/startsNum.ts
+function startsNum(str, substring) {
+  if (substring.length === 0) return 0;
+  let count = 0;
+  let index = 0;
+  while (str.startsWith(substring, index)) {
+    count++;
+    index += substring.length;
+  }
+  return count;
+}
+
+export {
+  startsNum
+};

package/dist/chunk-PLNZCEDI.js

@@ -0,0 +1,442 @@
+// packages/judge/judge.ts
+function judgeTest(a, b) {
+  return a.test(b);
+}
+function isEmpty(str) {
+  return typeof str == "undefined" || str == null || (str = str + "", str.trim() == "" || str.trim() == "undefined" || str.trim() == "null");
+}
+function isNotEmpty(str) {
+  return !isEmpty(str);
+}
+function isDate(strValue) {
+  if (isEmpty(strValue)) return false;
+  let r = strValue.match(/^(\d{4})(-|\/)(\d{2})\2(\d{2})$/);
+  if (r == null) return false;
+  let d = new Date(Number(r[1]), Number(r[3]) - 1, Number(r[4]));
+  return d.getFullYear() == Number(r[1]) && d.getMonth() + 1 == Number(r[3]) && d.getDate() == Number(r[4]);
+}
+function isDateTime(str) {
+  let reg = /^(\d{4})(-|\/)(\d{2})\2(\d{2}) (\d{2}):(\d{2}):(\d{2})$/;
+  let r = str.match(reg);
+  if (r == null) return false;
+  let d = new Date(
+    Number(r[1]),
+    Number(r[3]) - 1,
+    Number(r[4]),
+    Number(r[5]),
+    Number(r[6]),
+    Number(r[7])
+  );
+  return d.getFullYear() == Number(r[1]) && d.getMonth() + 1 == Number(r[3]) && d.getDate() == Number(r[4]) && d.getHours() == Number(r[5]) && d.getMinutes() == Number(r[6]) && d.getSeconds() == Number(r[7]);
+}
+function isAlphaNumeric(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[A-Za-z0-9]+$/;
+  return judgeTest(pattern, strValue);
+}
+function isCnAndEnNumeric(strValue) {
+  let pattern = /^[_0-9a-zA-Z\u4e00-\u9fa5]+$/;
+  return judgeTest(pattern, strValue);
+}
+function isEnNumeric(strValue) {
+  let pattern = /^[_0-9a-zA-Z]+$/;
+  return judgeTest(pattern, strValue);
+}
+function isCnAndEn(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[\u4e00-\u9fa5]+$/;
+  return judgeTest(pattern, strValue);
+}
+function isEmail(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^([a-zA-Z0-9]+[_|\-|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\-|\.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,3}$/;
+  return judgeTest(pattern, strValue);
+}
+function isMoney(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[+-]?\d+(,\d{3})*(\.\d+)?$/;
+  return judgeTest(pattern, strValue);
+}
+function isNumeric(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[0-9]*$/;
+  return judgeTest(pattern, strValue);
+}
+function isNumberFloat(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^\d+(\.\d+)?$/;
+  return judgeTest(pattern, strValue);
+}
+function isMobile(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^(1)[0-9]{10}$/;
+  return judgeTest(pattern, strValue);
+}
+function isPhone(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /(^\(\d{3,5}\)\d{6,8}(-\d{2,8})?$)|(^\d+-\d+$)|(^(1)[0-9]{10}$)/;
+  return judgeTest(pattern, strValue);
+}
+function isFax(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/;
+  return judgeTest(pattern, strValue);
+}
+function isTel(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^(([0\+]\d{2,3}-)?(0\d{2,3})-)(\d{7,8})(-(\d{3,}))?$/;
+  return judgeTest(pattern, strValue);
+}
+function isPostalCode(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /(^\d{6}$)/;
+  return judgeTest(pattern, strValue);
+}
+function isURL(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^(http|https|ftp):\/\/(\w+\.)+[a-z]{2,3}(\/\w+)*(\/\w+\.\w+)*(\?\w+=\w*(&\w+=\w*)*)*/;
+  return judgeTest(pattern, strValue);
+}
+function isCardID(strValue) {
+  if (isEmpty(strValue)) {
+    return false;
+  }
+  strValue = strValue.toUpperCase();
+  let vcity = {
+    11: "\u5317\u4EAC",
+    12: "\u5929\u6D25",
+    13: "\u6CB3\u5317",
+    14: "\u5C71\u897F",
+    15: "\u5185\u8499\u53E4",
+    21: "\u8FBD\u5B81",
+    22: "\u5409\u6797",
+    23: "\u9ED1\u9F99\u6C5F",
+    31: "\u4E0A\u6D77",
+    32: "\u6C5F\u82CF",
+    33: "\u6D59\u6C5F",
+    34: "\u5B89\u5FBD",
+    35: "\u798F\u5EFA",
+    36: "\u6C5F\u897F",
+    37: "\u5C71\u4E1C",
+    41: "\u6CB3\u5357",
+    42: "\u6E56\u5317",
+    43: "\u6E56\u5357",
+    44: "\u5E7F\u4E1C",
+    45: "\u5E7F\u897F",
+    46: "\u6D77\u5357",
+    50: "\u91CD\u5E86",
+    51: "\u56DB\u5DDD",
+    52: "\u8D35\u5DDE",
+    53: "\u4E91\u5357",
+    54: "\u897F\u85CF",
+    61: "\u9655\u897F",
+    62: "\u7518\u8083",
+    63: "\u9752\u6D77",
+    64: "\u5B81\u590F",
+    65: "\u65B0\u7586",
+    71: "\u53F0\u6E7E",
+    81: "\u9999\u6E2F",
+    82: "\u6FB3\u95E8",
+    91: "\u56FD\u5916"
+  };
+  let pattern = /(^\d{15}$)|(^\d{17}(\d|X)$)/;
+  if (judgeTest(pattern, strValue) === false) {
+    return false;
+  }
+  let province = strValue.substring(0, 2);
+  if (vcity[province] == void 0) {
+    return false;
+  }
+  let len = strValue.length;
+  if (len == 15) {
+    let re_fifteen = /^(\d{6})(\d{2})(\d{2})(\d{2})(\d{3})$/;
+    let arr_data = strValue.match(re_fifteen) || [];
+    let year = Number("19" + arr_data[2]);
+    let month = Number(arr_data[3]);
+    let day = Number(arr_data[4]);
+    let birthday = /* @__PURE__ */ new Date("19" + year + "/" + month + "/" + day);
+    birthday.setFullYear(year);
+    birthday.setMonth(month - 1);
+    birthday.setDate(day);
+    let now = /* @__PURE__ */ new Date();
+    let now_year = now.getFullYear();
+    if (birthday.getFullYear() == year && birthday.getMonth() + 1 == month && birthday.getDate() == day) {
+      let time = now_year - year;
+      if (!(time >= 3 && time <= 200)) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  if (len == 18) {
+    let re_eighteen = /^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$/;
+    let arr_data = strValue.match(re_eighteen) || [];
+    let year = Number(arr_data[2]);
+    let month = Number(arr_data[3]);
+    let day = Number(arr_data[4]);
+    let birthday = /* @__PURE__ */ new Date(year + "/" + month + "/" + day);
+    birthday.setFullYear(year);
+    birthday.setMonth(month - 1);
+    birthday.setDate(day);
+    let now = /* @__PURE__ */ new Date();
+    let now_year = now.getFullYear();
+    if (birthday.getFullYear() == year && birthday.getMonth() + 1 == month && birthday.getDate() == day) {
+      let time = now_year - year;
+      if (!(time >= 3 && time <= 200)) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  if (strValue.length == 15) {
+    let arrInt = new Array(
+      7,
+      9,
+      10,
+      5,
+      8,
+      4,
+      2,
+      1,
+      6,
+      3,
+      7,
+      9,
+      10,
+      5,
+      8,
+      4,
+      2
+    );
+    let arrCh = new Array(
+      "1",
+      "0",
+      "X",
+      "9",
+      "8",
+      "7",
+      "6",
+      "5",
+      "4",
+      "3",
+      "2"
+    );
+    let cardTemp = 0, i;
+    strValue = strValue.substring(0, 6) + "19" + strValue.substring(6, strValue.length - 6);
+    for (i = 0; i < 17; i++) {
+      cardTemp += Number(strValue.substring(i, 1)) * arrInt[i];
+    }
+    strValue += arrCh[cardTemp % 11];
+  }
+  if (strValue.length == 18) {
+    let arrInt = new Array(
+      7,
+      9,
+      10,
+      5,
+      8,
+      4,
+      2,
+      1,
+      6,
+      3,
+      7,
+      9,
+      10,
+      5,
+      8,
+      4,
+      2
+    );
+    let arrCh = new Array(
+      "1",
+      "0",
+      "X",
+      "9",
+      "8",
+      "7",
+      "6",
+      "5",
+      "4",
+      "3",
+      "2"
+    );
+    let cardTemp = 0, i, valnum;
+    for (i = 0; i < 17; i++) {
+      cardTemp += Number.parseInt(strValue.substring(i, 1)) * arrInt[i];
+    }
+    valnum = arrCh[cardTemp % 11];
+    if (valnum != strValue.substring(17, 1)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPwd(strValue) {
+  if (isEmpty(strValue)) return false;
+  let pattern = /^[0-9]{6}$/;
+  return judgeTest(pattern, strValue);
+}
+function isStrongPwd(strValue, filters = []) {
+  if (!judgeTest(/^\d{6}$/, strValue)) return false;
+  if (judgeTest(/([\d])\1{2}/, strValue)) return false;
+  let str = strValue.replace(/\d/g, ($0, pos) => {
+    return Number.parseInt($0) - Number.parseInt(pos) + "";
+  });
+  if (judgeTest(/^(\d)\1+$/, str)) return false;
+  str = strValue.replace(/\d/g, ($0, pos) => {
+    return Number.parseInt($0) + pos;
+  });
+  if (judgeTest(/^(\d)\1+$/, str)) return false;
+  let temp = "";
+  for (let i = 0; i < strValue.length; i++) {
+    let c = strValue.charAt(i);
+    if (temp.indexOf(c) == -1) {
+      temp += c;
+    }
+  }
+  if (temp.length <= 2) return false;
+  let flag = true;
+  let map = {};
+  for (let i = 0; i < strValue.length; i++) {
+    let c = strValue.charAt(i);
+    if (isEmpty(map[c])) {
+      map[c] = 0;
+    }
+    map[c] = map[c] + 1;
+    if (map[c] >= strValue.length / 2) {
+      flag = false;
+    }
+  }
+  if (flag == false) {
+    return false;
+  }
+  if (filters && filters.length > 0) {
+    for (let i = 0; i < filters.length; i++) {
+      let filter = filters[i];
+      if (filter.indexOf(strValue) > -1) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isBankCode(strValue) {
+  strValue = strValue.trim();
+  if (!isNumeric(strValue)) {
+    return false;
+  }
+  let length = strValue.length;
+  if (length < 12) {
+    return false;
+  } else if (length > 19 || length == 18) {
+    return true;
+  }
+  let flag = true;
+  let i = 0, mark = 0, temp = 0;
+  while (i < length - 1) {
+    mark += Number.parseInt(strValue.charAt(i));
+    i++;
+    temp = Number.parseInt(strValue.charAt(i)) * 2;
+    i++;
+    mark = Math.floor(temp / 10) + temp % 10;
+  }
+  if (mark % 10 == 0) {
+    flag = true;
+  } else {
+    flag = Number.parseInt(strValue.charAt(length - 1)) == 10 - mark % 10 || Number.parseInt(strValue.charAt(length - 1)) == mark % 10;
+  }
+  if (!flag) {
+    let lastNum = strValue.substring(
+      strValue.length - 1,
+      1
+    );
+    let first15Num = strValue.substring(0, strValue.length - 1);
+    let newArr = [];
+    for (let i2 = first15Num.length - 1; i2 > -1; i2--) {
+      newArr.push(first15Num.substring(i2, 1));
+    }
+    let arrJiShu = [];
+    let arrJiShu2 = [];
+    let arrOuShu = [];
+    for (let j = 0; j < newArr.length; j++) {
+      if ((j + 1) % 2 == 1) {
+        if (Number.parseInt(newArr[j]) * 2 < 9)
+          arrJiShu.push(Number.parseInt(newArr[j]) * 2);
+        else arrJiShu2.push(Number.parseInt(newArr[j]) * 2);
+      } else arrOuShu.push(newArr[j]);
+    }
+    let jishu_child1 = [];
+    let jishu_child2 = [];
+    for (let h = 0; h < arrJiShu2.length; h++) {
+      jishu_child1.push(arrJiShu2[h] % 10);
+      jishu_child2.push(arrJiShu2[h] / 10);
+    }
+    let sumJiShu = 0;
+    let sumOuShu = 0;
+    let sumJiShuChild1 = 0;
+    let sumJiShuChild2 = 0;
+    let sumTotal = 0;
+    for (let m = 0; m < arrJiShu.length; m++) {
+      sumJiShu = sumJiShu + arrJiShu[m];
+    }
+    for (let n = 0; n < arrOuShu.length; n++) {
+      sumOuShu = sumOuShu + Number.parseInt(arrOuShu[n]);
+    }
+    for (let p = 0; p < jishu_child1.length; p++) {
+      sumJiShuChild1 = sumJiShuChild1 + jishu_child1[p];
+      sumJiShuChild2 = sumJiShuChild2 + jishu_child2[p];
+    }
+    sumTotal = sumJiShu + sumOuShu + sumJiShuChild1 + sumJiShuChild2;
+    let k = sumTotal % 10 == 0 ? 10 : sumTotal % 10;
+    let luhm = 10 - k;
+    lastNum = Number.parseInt(lastNum);
+    flag = lastNum == luhm || luhm % lastNum == 0 || lastNum % luhm == 0 || lastNum + luhm == 10;
+  }
+  return flag;
+}
+function isQq(a) {
+  if (isEmpty(a)) return false;
+  let d = /^[1-9]\d{4,11}$/;
+  return judgeTest(d, a);
+}
+function isFormatNumber(a, b = 2) {
+  if (isEmpty(a)) return false;
+  let d = new RegExp("^[0-9]+.[0-9]{" + b + "}$");
+  return judgeTest(d, a);
+}
+function isWeChat(a) {
+  if (isEmpty(a)) return false;
+  let d = /^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/;
+  return judgeTest(d, a);
+}
+
+export {
+  isEmpty,
+  isNotEmpty,
+  isDate,
+  isDateTime,
+  isAlphaNumeric,
+  isCnAndEnNumeric,
+  isEnNumeric,
+  isCnAndEn,
+  isEmail,
+  isMoney,
+  isNumeric,
+  isNumberFloat,
+  isMobile,
+  isPhone,
+  isFax,
+  isTel,
+  isPostalCode,
+  isURL,
+  isCardID,
+  isPwd,
+  isStrongPwd,
+  isBankCode,
+  isQq,
+  isFormatNumber,
+  isWeChat
+};

package/dist/chunk-PSHKOVLY.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkVJUGYXBCcjs = require('./chunk-VJUGYXBC.cjs');
+
+
+var _chunkUGT4QBTMcjs = require('./chunk-UGT4QBTM.cjs');
+
+
+var _chunk4BGJIMWMcjs = require('./chunk-4BGJIMWM.cjs');
+
+
+var _chunk75ZPJI57cjs = require('./chunk-75ZPJI57.cjs');
+
+// packages/basic/index.ts
+var basic_exports = {};
+_chunk75ZPJI57cjs.__export.call(void 0, basic_exports, {
+  array: () => _chunk4BGJIMWMcjs.array_exports,
+  object: () => _chunkUGT4QBTMcjs.object_exports,
+  string: () => _chunkVJUGYXBCcjs.string_exports
+});
+
+
+
+exports.basic_exports = basic_exports;

package/dist/{chunk-V5HVA7TW.cjs → chunk-PV2N6PF2.cjs}

@@ -5,6 +5,11 @@
 var _chunkYAD5PHVFcjs = require('./chunk-YAD5PHVF.cjs');
 
 
+
+
+var _chunkRYBJGHXKcjs = require('./chunk-RYBJGHXK.cjs');
+
+
 var _chunk75ZPJI57cjs = require('./chunk-75ZPJI57.cjs');
 
 // packages/tree/index.ts
@@ -12,6 +17,9 @@ var tree_exports = {};
 _chunk75ZPJI57cjs.__export.call(void 0, tree_exports, {
   arrayToTree: () => _chunkYAD5PHVFcjs.arrayToTree,
   getTreeObj: () => _chunkYAD5PHVFcjs.getTreeObj,
+  splitGroup: () => _chunkRYBJGHXKcjs.splitGroup,
+  splitGroupDitto: () => _chunkRYBJGHXKcjs.splitGroupDitto,
+  splitGroupExist: () => _chunkRYBJGHXKcjs.splitGroupExist,
   treeToArray: () => _chunkYAD5PHVFcjs.treeToArray
 });
 

package/dist/chunk-QXK4IUBI.cjs

@@ -0,0 +1,142 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// packages/basic/string/toFunction.ts
+function extractParams(paramStr) {
+  const result = [];
+  let depth = 0;
+  let current = "";
+  let inString = false;
+  let quoteType = "";
+  let lastChar = "";
+  for (let i = 0; i < paramStr.length; i++) {
+    const char = paramStr[i];
+    if (lastChar === "\\") {
+      current += char;
+      lastChar = char;
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'" || char === "`")) {
+      inString = true;
+      quoteType = char;
+    } else if (inString && char === quoteType) {
+      inString = false;
+    }
+    if (quoteType === "`" && char === "$" && i < paramStr.length - 1 && paramStr[i + 1] === "{") {
+      depth++;
+    } else if (quoteType === "`" && depth > 0 && char === "}") {
+      depth--;
+    }
+    if (char === "," && depth === 0 && !inString) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      if (char === "(" || char === "{" || char === "[") depth++;
+      else if (char === ")" || char === "}" || char === "]") depth--;
+      current += char;
+    }
+    lastChar = char;
+  }
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+function toFunction(str, key) {
+  try {
+    const obj = getFunctionFormat(str);
+    if (!_optionalChain([obj, 'optionalAccess', _2 => _2.body])) return void 0;
+    const params = obj.param ? extractParams(obj.param) : [];
+    if (params.length > 1e3) {
+      throw new Error("Too many parameters (max: 1000)");
+    }
+    if (obj.isAsync) {
+      try {
+        const fullFunction = `async function${obj.isGenerator ? "*" : ""} ${_nullishCoalesce(_nullishCoalesce(obj.name, () => ( key)), () => ( ""))} (${obj.param}) { ${obj.body} }`;
+        return new Function(`return ${fullFunction}`)();
+      } catch (error) {
+        const fullFunction = `async function${obj.isGenerator ? "*" : ""} (${obj.param}) { ${obj.body} }`;
+        return new Function(`return ${fullFunction}`)();
+      }
+    } else {
+      try {
+        const fullFunction = `function${obj.isGenerator ? "*" : ""} ${_nullishCoalesce(_nullishCoalesce(obj.name, () => ( key)), () => ( ""))}(${obj.param}) { ${obj.body} }`;
+        return new Function(`return (${fullFunction})`)();
+      } catch (error) {
+        return new Function(...params, obj.body);
+      }
+    }
+  } catch (error) {
+    console.error("Function creation failed:", {
+      input: str.slice(0, 100),
+      error
+    });
+    return void 0;
+  }
+}
+var FUNCTION_REGEX = /^\s*(?:(async)\s+)?(?:function\s*(\*?)\s*(\w*)\s*\(([\s\S]*?)\)|(\*?\s*)\b(\w+)\s*\(([\s\S]*?)\)|\(([\s\S]*?)\)|([^=>,\(\)]+?))\s*(?:=>)?\s*(?:\{([\s\S]*?)\}|([\s\S]*))$/;
+function getFunctionFormat(v) {
+  if (!v) return;
+  const str = typeof v === "function" ? v.toString() : v;
+  const trimmed = str.trim();
+  const match = trimmed.match(FUNCTION_REGEX);
+  if (!match) {
+    console.warn("Unsupported function format:", trimmed.slice(0, 100));
+    return;
+  }
+  const [
+    _,
+    // 完整匹配
+    asyncFlag,
+    // 异步标志
+    funcGenerator,
+    // 函数生成器标志
+    funcName,
+    // 函数名称
+    funcParams,
+    // 函数参数
+    methodGenerator,
+    // 方法生成器标志
+    methodName,
+    // 方法名称
+    methodParams,
+    // 方法参数
+    arrowParenParams,
+    // 箭头函数括号参数
+    arrowSingleParam,
+    // 箭头函数单参数
+    blockBody,
+    // 块级函数体
+    exprBody
+    // 表达式函数体
+  ] = match;
+  let isAsync = !!asyncFlag;
+  let isGenerator = false;
+  let name = "";
+  let param = "";
+  let body = "";
+  if (funcParams !== void 0) {
+    isGenerator = funcGenerator === "*";
+    name = funcName || "";
+    param = funcParams;
+    body = blockBody || exprBody || "";
+  } else if (methodParams !== void 0) {
+    isGenerator = _optionalChain([methodGenerator, 'optionalAccess', _3 => _3.includes, 'call', _4 => _4("*")]) || false;
+    name = methodName || "";
+    param = methodParams;
+    body = blockBody || exprBody || "";
+  } else if (arrowParenParams !== void 0 || arrowSingleParam !== void 0) {
+    param = arrowParenParams || arrowSingleParam || "";
+    body = blockBody || exprBody || "";
+    if (!blockBody && !/^\s*return\b/.test(body)) {
+      body = `return ${body}`;
+    }
+  }
+  return {
+    isAsync,
+    isGenerator,
+    ...name && { name },
+    param: param.trim(),
+    body: body.trim()
+  };
+}
+
+
+
+
+exports.toFunction = toFunction; exports.getFunctionFormat = getFunctionFormat;