@fangzhongya/utils 0.0.9 → 0.0.15

package/dist/chunk-754Z5VW6.js

@@ -0,0 +1,29 @@
+// packages/basic/object/objValue.ts
+function getObjValue(key, locale) {
+  if (!key) return locale;
+  const path = key.split(".");
+  let result = locale;
+  for (const prop of path) {
+    if (result == null || typeof result !== "object") return void 0;
+    result = result[prop];
+  }
+  return result;
+}
+function setObjValue(locale, key, value) {
+  if (!key) return Object.assign(locale, value);
+  const path = key.split(".");
+  const lastKey = path.pop();
+  let current = locale;
+  for (const prop of path) {
+    if (!current[prop] || typeof current[prop] !== "object") {
+      current[prop] = {};
+    }
+    current = current[prop];
+  }
+  current[lastKey] = value;
+}
+
+export {
+  getObjValue,
+  setObjValue
+};

package/dist/chunk-7O4MJOHM.js

@@ -0,0 +1,142 @@
+// 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 (!obj?.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 ? "*" : ""} ${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 ? "*" : ""} ${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 = methodGenerator?.includes("*") || 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()
+  };
+}
+
+export {
+  toFunction,
+  getFunctionFormat
+};

package/dist/chunk-E4WBX6J5.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// packages/basic/object/objValue.ts
+function getObjValue(key, locale) {
+  if (!key) return locale;
+  const path = key.split(".");
+  let result = locale;
+  for (const prop of path) {
+    if (result == null || typeof result !== "object") return void 0;
+    result = result[prop];
+  }
+  return result;
+}
+function setObjValue(locale, key, value) {
+  if (!key) return Object.assign(locale, value);
+  const path = key.split(".");
+  const lastKey = path.pop();
+  let current = locale;
+  for (const prop of path) {
+    if (!current[prop] || typeof current[prop] !== "object") {
+      current[prop] = {};
+    }
+    current = current[prop];
+  }
+  current[lastKey] = value;
+}
+
+
+
+
+exports.getObjValue = getObjValue; exports.setObjValue = setObjValue;

package/dist/chunk-ETMYYVQJ.cjs

@@ -0,0 +1,432 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkQXK4IUBIcjs = require('./chunk-QXK4IUBI.cjs');
+
+
+var _chunkE4WBX6J5cjs = require('./chunk-E4WBX6J5.cjs');
+
+// packages/basic/string/toJsons.ts
+var TYPE_MARKERS = {
+  FUNCTION_REF: "_FR_",
+  CODE_BLOCK: "_CB_",
+  /**内置对象*/
+  SYMBOL: "_Sy_",
+  FUNCTION: "_F_",
+  UNDEFINED: "_UN_",
+  DATE: "_D_",
+  REGEXP: "_R_",
+  NAN: "_N_",
+  BIGINT: "_BI_",
+  MAP: "_M_",
+  SET: "_S_",
+  ARRAY_BUFFER: "_AB_",
+  TYPED_ARRAY: "_TA_",
+  DATA_VIEW: "_DV_",
+  ERROR: "_E_",
+  URL: "_U_",
+  INFINITY: "_I_",
+  NEGATIVE_INFINITY: "_NI_",
+  INT8_ARRAY: "_I8_",
+  UINT8_ARRAY: "_U8_",
+  UINT8_CLAMPED_ARRAY: "_U8C_",
+  INT16_ARRAY: "_I1_",
+  UINT16_ARRAY: "_U1_",
+  INT32_ARRAY: "_I3_",
+  UINT32_ARRAY: "_U3_",
+  FLOAT32_ARRAY: "_F3_",
+  FLOAT64_ARRAY: "_F6_",
+  BIGINT64_ARRAY: "_BI6_",
+  BIGUINT64_ARRAY: "_BU6_"
+};
+var arrayBufferUtils = {
+  // 将ArrayBuffer编码为Base64字符串
+  encode: (buffer) => {
+    if (typeof Buffer !== "undefined") {
+      const bytes = new Uint8Array(buffer);
+      let binary = "";
+      bytes.forEach((byte) => binary += String.fromCharCode(byte));
+      return btoa(binary);
+    }
+    if (typeof btoa === "function") {
+      const bytes = new Uint8Array(buffer);
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      return btoa(binary);
+    }
+    throw new Error(
+      "ArrayBuffer encoding not supported in this environment"
+    );
+  },
+  // 将Base64字符串解码为ArrayBuffer
+  decode: (base64Str) => {
+    if (typeof Buffer !== "undefined") {
+      const binaryString = atob(base64Str);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes.buffer;
+    }
+    if (typeof atob === "function") {
+      const binaryString = atob(base64Str);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes.buffer;
+    }
+    throw new Error(
+      "ArrayBuffer decoding not supported in this environment"
+    );
+  },
+  // 获取ArrayBuffer的字节数组表示
+  toByteArray: (buffer) => {
+    return Array.from(new Uint8Array(buffer));
+  },
+  // 从字节数组创建ArrayBuffer
+  fromByteArray: (array) => {
+    const buffer = new ArrayBuffer(array.length);
+    const view = new Uint8Array(buffer);
+    array.forEach((value, index) => view[index] = value);
+    return buffer;
+  }
+};
+function toJSONSStringify(obj, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    function(key, value) {
+      if (value === null) {
+        return null;
+      }
+      if (typeof value === "object") {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      if (this[key] instanceof Date) {
+        return {
+          [TYPE_MARKERS.DATE]: this[key].getTime()
+        };
+      }
+      if (this[key] instanceof URL) {
+        return {
+          [TYPE_MARKERS.URL]: this[key].href
+        };
+      }
+      if (value === Infinity) {
+        return { [TYPE_MARKERS.INFINITY]: 1 };
+      }
+      if (value === -Infinity) {
+        return { [TYPE_MARKERS.NEGATIVE_INFINITY]: 1 };
+      }
+      if (value === void 0) {
+        return { [TYPE_MARKERS.UNDEFINED]: 1 };
+      }
+      if (Object.is(value, NaN)) {
+        return { [TYPE_MARKERS.NAN]: 1 };
+      }
+      switch (typeof value) {
+        case "bigint":
+          return { [TYPE_MARKERS.BIGINT]: value.toString() };
+        case "symbol":
+          return {
+            [TYPE_MARKERS.SYMBOL]: {
+              k: _nullishCoalesce(Symbol.keyFor(value), () => ( 0)),
+              d: value.description || ""
+            }
+          };
+        case "function":
+          return {
+            [TYPE_MARKERS.FUNCTION]: value.toString()
+          };
+        case "object":
+          if (value instanceof RegExp) {
+            return {
+              [TYPE_MARKERS.REGEXP]: {
+                s: value.source,
+                f: value.flags
+              }
+            };
+          }
+          if (value instanceof Map) {
+            return {
+              [TYPE_MARKERS.MAP]: Array.from(value.entries())
+            };
+          }
+          if (value instanceof Set) {
+            return {
+              [TYPE_MARKERS.SET]: Array.from(value.values())
+            };
+          }
+          if (value instanceof ArrayBuffer) {
+            return {
+              [TYPE_MARKERS.ARRAY_BUFFER]: arrayBufferUtils.encode(value)
+            };
+          }
+          if (value instanceof Int8Array) {
+            return {
+              [TYPE_MARKERS.INT8_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Uint8Array) {
+            return {
+              [TYPE_MARKERS.UINT8_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Uint8ClampedArray) {
+            return {
+              [TYPE_MARKERS.UINT8_CLAMPED_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Int16Array) {
+            return {
+              [TYPE_MARKERS.INT16_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Uint16Array) {
+            return {
+              [TYPE_MARKERS.UINT16_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Int32Array) {
+            return {
+              [TYPE_MARKERS.INT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Uint32Array) {
+            return {
+              [TYPE_MARKERS.UINT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Float32Array) {
+            return {
+              [TYPE_MARKERS.FLOAT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof Float64Array) {
+            return {
+              [TYPE_MARKERS.FLOAT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof BigInt64Array) {
+            return {
+              [TYPE_MARKERS.BIGINT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof BigUint64Array) {
+            return {
+              [TYPE_MARKERS.BIGUINT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer)
+            };
+          }
+          if (value instanceof DataView) {
+            return {
+              [TYPE_MARKERS.DATA_VIEW]: {
+                b: arrayBufferUtils.encode(
+                  value.buffer
+                ),
+                o: value.byteOffset,
+                l: value.byteLength
+              }
+            };
+          }
+          if (value instanceof Error) {
+            return {
+              [TYPE_MARKERS.ERROR]: {
+                n: value.name,
+                m: value.message,
+                s: value.stack
+              }
+            };
+          }
+      }
+      return value;
+    },
+    space
+  );
+}
+function toJSONSParse(str, context) {
+  try {
+    const parsed = JSON.parse(str, (key, value) => {
+      if (value && typeof value === "object") {
+        const markers = Object.keys(value);
+        if (markers.length === 1) {
+          const marker = markers[0];
+          const markerValue = value[marker];
+          switch (marker) {
+            case TYPE_MARKERS.BIGINT:
+              return BigInt(markerValue);
+            case TYPE_MARKERS.SYMBOL:
+              return markerValue.k ? Symbol.for(markerValue.k) : Symbol(markerValue.d);
+            case TYPE_MARKERS.FUNCTION:
+              return _chunkQXK4IUBIcjs.toFunction.call(void 0, markerValue, key) || function() {
+              };
+            case TYPE_MARKERS.NAN:
+              return NaN;
+            case TYPE_MARKERS.INFINITY:
+              return Infinity;
+            case TYPE_MARKERS.NEGATIVE_INFINITY:
+              return -Infinity;
+            case TYPE_MARKERS.FUNCTION_REF:
+              return context ? _chunkE4WBX6J5cjs.getObjValue.call(void 0, markerValue, context) : void 0;
+            case TYPE_MARKERS.CODE_BLOCK:
+              return getCodeBlock(markerValue, key);
+          }
+        }
+      }
+      return value;
+    });
+    return restoreSpecialValues(parsed);
+  } catch (error) {
+    console.error("JSON parse error:", {
+      str: str.slice(0, 200) + "...",
+      error
+    });
+    return {};
+  }
+}
+function restoreSpecialValues(obj, depth = 0) {
+  if (depth > 100) throw new Error("Recursion limit exceeded");
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      const converted = convertSpecialValue(item);
+      if (converted !== item) {
+        return converted;
+      }
+      return restoreSpecialValues(item, depth + 1);
+    });
+  }
+  const result = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      let value = obj[key];
+      const converted = convertSpecialValue(value);
+      if (converted !== value) {
+        value = converted;
+      } else {
+        value = restoreSpecialValues(value, depth + 1);
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function convertSpecialValue(value) {
+  if (value && typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 1) {
+      const [marker] = keys;
+      const markerValue = value[marker];
+      switch (marker) {
+        case TYPE_MARKERS.UNDEFINED:
+          return void 0;
+        case TYPE_MARKERS.DATE:
+          return new Date(markerValue);
+        // 从时间戳恢复Date
+        case TYPE_MARKERS.REGEXP: {
+          return new RegExp(markerValue.s, markerValue.f);
+        }
+        case TYPE_MARKERS.MAP:
+          return new Map(markerValue);
+        case TYPE_MARKERS.SET:
+          return new Set(markerValue);
+        case TYPE_MARKERS.ARRAY_BUFFER:
+          return arrayBufferUtils.decode(markerValue);
+        case TYPE_MARKERS.ERROR: {
+          const { n, m, s } = markerValue;
+          const error = new Error(m);
+          error.name = n;
+          error.stack = s;
+          return error;
+        }
+        case TYPE_MARKERS.URL:
+          return new URL(markerValue);
+        // 处理所有TypedArray类型
+        case TYPE_MARKERS.INT8_ARRAY:
+          return new Int8Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.UINT8_ARRAY:
+          return new Uint8Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.UINT8_CLAMPED_ARRAY:
+          return new Uint8ClampedArray(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.INT16_ARRAY:
+          return new Int16Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.UINT16_ARRAY:
+          return new Uint16Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.INT32_ARRAY:
+          return new Int32Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.UINT32_ARRAY:
+          return new Uint32Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.FLOAT32_ARRAY:
+          return new Float32Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.FLOAT64_ARRAY:
+          return new Float64Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.BIGINT64_ARRAY:
+          return new BigInt64Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.BIGUINT64_ARRAY:
+          return new BigUint64Array(
+            arrayBufferUtils.fromByteArray(markerValue)
+          );
+        case TYPE_MARKERS.DATA_VIEW: {
+          const buffer = arrayBufferUtils.decode(markerValue.b);
+          return new DataView(buffer, markerValue.o, markerValue.l);
+        }
+      }
+    }
+  }
+  return value;
+}
+function getCodeBlock(value, key) {
+  try {
+    try {
+      const fullFunction = `function ${_nullishCoalesce(_nullishCoalesce(value.name, () => ( key)), () => ( ""))}(${value.params.join(",")}) { ${value.body} }`;
+      return new Function(`"use strict";
+				 return (${fullFunction})`)();
+    } catch (error) {
+      return new Function(
+        ...value.params,
+        `"use strict";
+				 ${value.body}`
+      );
+    }
+  } catch (error) {
+    console.error("Code block execution failed", error);
+    return value;
+  }
+}
+function serializeFunctionRef(key) {
+  return { [TYPE_MARKERS.FUNCTION_REF]: key };
+}
+function serializeCodeBlock(value) {
+  return { [TYPE_MARKERS.CODE_BLOCK]: value };
+}
+
+
+
+
+
+
+exports.toJSONSStringify = toJSONSStringify; exports.toJSONSParse = toJSONSParse; exports.serializeFunctionRef = serializeFunctionRef; exports.serializeCodeBlock = serializeCodeBlock;

package/dist/{chunk-QJVB3JIZ.js → chunk-HWR2FRME.js}

@@ -1,5 +1,5 @@
 // packages/node/getPort.ts
-import { createServer } from "node:net";
+import { createServer } from "net";
 function getPort(host, port = 5173, isLocal = true) {
   return new Promise((resolve, reject) => {
     isPortOccupied(port, host, isLocal).then((v) => {

package/dist/{chunk-22VNKNCE.js → chunk-IEQHKLEL.js}

@@ -1,21 +1,19 @@
-import {
-  unmergeObject
-} from "./chunk-A6J46LQK.js";
-import {
-  getSort
-} from "./chunk-ZEAT23CI.js";
-import {
-  hasOwn
-} from "./chunk-3IR2ABRO.js";
 import {
   mergeObject
 } from "./chunk-RD4EP3M5.js";
+import {
+  getObjValue,
+  setObjValue
+} from "./chunk-754Z5VW6.js";
 import {
   reverseObj
 } from "./chunk-B3IGSYZT.js";
 import {
   setSort
 } from "./chunk-3LWFUVER.js";
+import {
+  unmergeObject
+} from "./chunk-A6J46LQK.js";
 import {
   attrValueSort
 } from "./chunk-T4BAVDTH.js";
@@ -25,6 +23,12 @@ import {
 import {
   filterObject
 } from "./chunk-S42NGJ5W.js";
+import {
+  getSort
+} from "./chunk-ZEAT23CI.js";
+import {
+  hasOwn
+} from "./chunk-3IR2ABRO.js";
 import {
   isObjectArray
 } from "./chunk-GYE23WAN.js";
@@ -41,12 +45,14 @@ __export(object_exports, {
   attrValueSort: () => attrValueSort,
   deepCopy: () => deepCopy,
   filterObject: () => filterObject,
+  getObjValue: () => getObjValue,
   getSort: () => getSort,
   hasOwn: () => hasOwn,
   isObject: () => isObject,
   isObjectArray: () => isObjectArray,
   mergeObject: () => mergeObject,
   reverseObj: () => reverseObj,
+  setObjValue: () => setObjValue,
   setSort: () => setSort,
   unmergeObject: () => unmergeObject
 });