@fangzhongya/utils 0.0.50 → 0.0.56

package/dist/chunk-SJ74DU4B.cjs

@@ -0,0 +1,275 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// packages/basic/object/deepCopys.ts
+function deepCopys(obj, options = {}) {
+  const {
+    visited = /* @__PURE__ */ new WeakMap(),
+    maxDepth = 100,
+    handleProxy = "unwrap",
+    currentDepth = 0
+  } = options;
+  if (currentDepth >= maxDepth) {
+    console.warn("deepCopys: Maximum depth reached, returning reference");
+    return obj;
+  }
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (typeof obj === "function") {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const isProxy = isProxyObject(obj);
+  if (isProxy) {
+    switch (handleProxy) {
+      case "unwrap":
+        const rawValue = getProxyTarget(obj);
+        if (rawValue !== obj) {
+          return deepCopys(rawValue, {
+            visited,
+            maxDepth,
+            handleProxy,
+            currentDepth: currentDepth + 1
+          });
+        }
+        break;
+      case "clone":
+        const target = getProxyTarget(obj);
+        if (target !== obj) {
+          const result = deepCopys(target, {
+            visited,
+            maxDepth,
+            handleProxy,
+            currentDepth: currentDepth + 1
+          });
+          visited.set(obj, result);
+          return result;
+        }
+        break;
+      case "keep":
+        return obj;
+    }
+  }
+  if (obj instanceof Date) {
+    const copy = new Date(obj.getTime());
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (obj instanceof RegExp) {
+    const copy = new RegExp(obj.source, obj.flags);
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (obj instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    visited.set(obj, copy);
+    obj.forEach((value, key) => {
+      copy.set(
+        deepCopys(key, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        }),
+        deepCopys(value, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        })
+      );
+    });
+    return copy;
+  }
+  if (obj instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    visited.set(obj, copy);
+    obj.forEach((value) => {
+      copy.add(
+        deepCopys(value, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        })
+      );
+    });
+    return copy;
+  }
+  if (obj instanceof ArrayBuffer) {
+    const copy = obj.slice(0);
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (ArrayBuffer.isView(obj)) {
+    const copy = obj.slice();
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (isPromise(obj)) {
+    return obj;
+  }
+  const objClone = Array.isArray(obj) ? [] : {};
+  visited.set(obj, objClone);
+  const keys = getAllPropertyKeys(obj);
+  for (const key of keys) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        obj,
+        key
+      );
+      if (descriptor && descriptor.get) {
+        continue;
+      }
+      const value = obj[key];
+      objClone[key] = deepCopys(value, {
+        visited,
+        maxDepth,
+        handleProxy,
+        currentDepth: currentDepth + 1
+      });
+    } catch (error) {
+      continue;
+    }
+  }
+  return objClone;
+}
+function isProxyObject(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  try {
+    if (obj && obj.__v_isReactive || obj.__v_isReadonly) {
+      return true;
+    }
+  } catch (e2) {
+  }
+  try {
+    const str = Object.prototype.toString.call(obj);
+    if (str === "[object Proxy]") {
+      return true;
+    }
+  } catch (e3) {
+  }
+  return false;
+}
+function getProxyTarget(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  try {
+    const raw = obj.__v_raw;
+    if (raw !== void 0) {
+      return raw;
+    }
+  } catch (e4) {
+  }
+  return obj;
+}
+function isPromise(obj) {
+  return obj && typeof obj === "object" && typeof obj.then === "function";
+}
+function getAllPropertyKeys(obj) {
+  const keys = [];
+  const ownKeys = Reflect.ownKeys(obj);
+  keys.push(...ownKeys);
+  return keys;
+}
+function safeDeepCopy(obj) {
+  try {
+    const rawObj = getRawReactiveValue(obj);
+    if (rawObj !== obj) {
+      return deepCopys(rawObj, {
+        handleProxy: "unwrap",
+        maxDepth: 50
+      });
+    }
+  } catch (error) {
+  }
+  return deepCopys(obj, {
+    handleProxy: "unwrap",
+    maxDepth: 50
+  });
+}
+function getRawReactiveValue(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  try {
+    const raw = obj.__v_raw;
+    if (raw !== void 0) {
+      return raw;
+    }
+  } catch (e5) {
+  }
+  try {
+    if (obj.__ob__) {
+      const plainObj = { ...obj };
+      delete plainObj.__ob__;
+      return plainObj;
+    }
+  } catch (e6) {
+  }
+  return obj;
+}
+function fastDeepCopy(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (e) {
+    console.warn("fastDeepCopy failed, falling back to deepCopys", e);
+    return deepCopys(obj, {
+      handleProxy: "unwrap",
+      maxDepth: 100
+    });
+  }
+}
+function structuredCloneCopy(obj) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(obj);
+    } catch (e) {
+      console.warn(
+        "structuredClone failed, falling back to deepCopys",
+        e
+      );
+      return deepCopys(obj);
+    }
+  }
+  return deepCopys(obj);
+}
+function isPlainObject(obj) {
+  return obj !== null && typeof obj === "object" && obj.constructor === Object;
+}
+function simpleDeepCopy(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => simpleDeepCopy(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  const copy = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      copy[key] = simpleDeepCopy(obj[key]);
+    }
+  }
+  return copy;
+}
+
+
+
+
+
+
+
+
+exports.deepCopys = deepCopys; exports.safeDeepCopy = safeDeepCopy; exports.fastDeepCopy = fastDeepCopy; exports.structuredCloneCopy = structuredCloneCopy; exports.isPlainObject = isPlainObject; exports.simpleDeepCopy = simpleDeepCopy;

package/dist/{chunk-53EIYZSN.cjs → chunk-SUAM6STT.cjs}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkQC5UCHB5cjs = require('./chunk-QC5UCHB5.cjs');
+var _chunkQHMO7DUJcjs = require('./chunk-QHMO7DUJ.cjs');
 
 
-var _chunkUCDL7HLXcjs = require('./chunk-UCDL7HLX.cjs');
+var _chunk3QR3J6AEcjs = require('./chunk-3QR3J6AE.cjs');
 
 
 var _chunk65O7KWP4cjs = require('./chunk-65O7KWP4.cjs');
@@ -15,8 +15,8 @@ var _chunk75ZPJI57cjs = require('./chunk-75ZPJI57.cjs');
 var basic_exports = {};
 _chunk75ZPJI57cjs.__export.call(void 0, basic_exports, {
   array: () => _chunk65O7KWP4cjs.array_exports,
-  object: () => _chunkUCDL7HLXcjs.object_exports,
-  string: () => _chunkQC5UCHB5cjs.string_exports
+  object: () => _chunk3QR3J6AEcjs.object_exports,
+  string: () => _chunkQHMO7DUJcjs.string_exports
 });
 
 

package/dist/{chunk-XU7MQD33.js → chunk-SVK3J3CY.js}

@@ -1,6 +1,12 @@
+import {
+  setSort
+} from "./chunk-3LWFUVER.js";
 import {
   unmergeObject
 } from "./chunk-A6J46LQK.js";
+import {
+  hasOwn
+} from "./chunk-3IR2ABRO.js";
 import {
   mergeObject
 } from "./chunk-RD4EP3M5.js";
@@ -11,24 +17,26 @@ import {
 import {
   reverseObj
 } from "./chunk-B3IGSYZT.js";
-import {
-  setSort
-} from "./chunk-3LWFUVER.js";
 import {
   attrValueSort
 } from "./chunk-T4BAVDTH.js";
 import {
   deepCopy
 } from "./chunk-PHKZER72.js";
+import {
+  deepCopys,
+  fastDeepCopy,
+  isPlainObject,
+  safeDeepCopy,
+  simpleDeepCopy,
+  structuredCloneCopy
+} from "./chunk-YMKTU42G.js";
 import {
   filterObject
 } from "./chunk-S42NGJ5W.js";
 import {
   getSort
 } from "./chunk-ZEAT23CI.js";
-import {
-  hasOwn
-} from "./chunk-3IR2ABRO.js";
 import {
   isEqual,
   isEqualEnhanced
@@ -48,6 +56,8 @@ var object_exports = {};
 __export(object_exports, {
   attrValueSort: () => attrValueSort,
   deepCopy: () => deepCopy,
+  deepCopys: () => deepCopys,
+  fastDeepCopy: () => fastDeepCopy,
   filterObject: () => filterObject,
   getObjValue: () => getObjValue,
   getSort: () => getSort,
@@ -56,10 +66,14 @@ __export(object_exports, {
   isEqualEnhanced: () => isEqualEnhanced,
   isObject: () => isObject,
   isObjectArray: () => isObjectArray,
+  isPlainObject: () => isPlainObject,
   mergeObject: () => mergeObject,
   reverseObj: () => reverseObj,
+  safeDeepCopy: () => safeDeepCopy,
   setObjValue: () => setObjValue,
   setSort: () => setSort,
+  simpleDeepCopy: () => simpleDeepCopy,
+  structuredCloneCopy: () => structuredCloneCopy,
   unmergeObject: () => unmergeObject
 });
 

package/dist/{chunk-7VGVDOZH.js → chunk-X44UO4CZ.js}

@@ -1,15 +1,3 @@
-import {
-  matchs
-} from "./chunk-T2QKEABG.js";
-import {
-  matchsEnd
-} from "./chunk-YNOFNHEK.js";
-import {
-  matchsStart
-} from "./chunk-S6JRKYPY.js";
-import {
-  matchsWhole
-} from "./chunk-IRGCP7KH.js";
 import {
   isAlphaNumeric,
   isBankCode,
@@ -37,6 +25,18 @@ import {
   isURL,
   isWeChat
 } from "./chunk-PLNZCEDI.js";
+import {
+  matchs
+} from "./chunk-33X65PQS.js";
+import {
+  matchsWhole
+} from "./chunk-IRGCP7KH.js";
+import {
+  matchsEnd
+} from "./chunk-YNOFNHEK.js";
+import {
+  matchsStart
+} from "./chunk-S6JRKYPY.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/chunk-YMKTU42G.js

@@ -0,0 +1,275 @@
+// packages/basic/object/deepCopys.ts
+function deepCopys(obj, options = {}) {
+  const {
+    visited = /* @__PURE__ */ new WeakMap(),
+    maxDepth = 100,
+    handleProxy = "unwrap",
+    currentDepth = 0
+  } = options;
+  if (currentDepth >= maxDepth) {
+    console.warn("deepCopys: Maximum depth reached, returning reference");
+    return obj;
+  }
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (typeof obj === "function") {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const isProxy = isProxyObject(obj);
+  if (isProxy) {
+    switch (handleProxy) {
+      case "unwrap":
+        const rawValue = getProxyTarget(obj);
+        if (rawValue !== obj) {
+          return deepCopys(rawValue, {
+            visited,
+            maxDepth,
+            handleProxy,
+            currentDepth: currentDepth + 1
+          });
+        }
+        break;
+      case "clone":
+        const target = getProxyTarget(obj);
+        if (target !== obj) {
+          const result = deepCopys(target, {
+            visited,
+            maxDepth,
+            handleProxy,
+            currentDepth: currentDepth + 1
+          });
+          visited.set(obj, result);
+          return result;
+        }
+        break;
+      case "keep":
+        return obj;
+    }
+  }
+  if (obj instanceof Date) {
+    const copy = new Date(obj.getTime());
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (obj instanceof RegExp) {
+    const copy = new RegExp(obj.source, obj.flags);
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (obj instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    visited.set(obj, copy);
+    obj.forEach((value, key) => {
+      copy.set(
+        deepCopys(key, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        }),
+        deepCopys(value, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        })
+      );
+    });
+    return copy;
+  }
+  if (obj instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    visited.set(obj, copy);
+    obj.forEach((value) => {
+      copy.add(
+        deepCopys(value, {
+          visited,
+          maxDepth,
+          handleProxy,
+          currentDepth: currentDepth + 1
+        })
+      );
+    });
+    return copy;
+  }
+  if (obj instanceof ArrayBuffer) {
+    const copy = obj.slice(0);
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (ArrayBuffer.isView(obj)) {
+    const copy = obj.slice();
+    visited.set(obj, copy);
+    return copy;
+  }
+  if (isPromise(obj)) {
+    return obj;
+  }
+  const objClone = Array.isArray(obj) ? [] : {};
+  visited.set(obj, objClone);
+  const keys = getAllPropertyKeys(obj);
+  for (const key of keys) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        obj,
+        key
+      );
+      if (descriptor && descriptor.get) {
+        continue;
+      }
+      const value = obj[key];
+      objClone[key] = deepCopys(value, {
+        visited,
+        maxDepth,
+        handleProxy,
+        currentDepth: currentDepth + 1
+      });
+    } catch (error) {
+      continue;
+    }
+  }
+  return objClone;
+}
+function isProxyObject(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  try {
+    if (obj && obj.__v_isReactive || obj.__v_isReadonly) {
+      return true;
+    }
+  } catch {
+  }
+  try {
+    const str = Object.prototype.toString.call(obj);
+    if (str === "[object Proxy]") {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function getProxyTarget(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  try {
+    const raw = obj.__v_raw;
+    if (raw !== void 0) {
+      return raw;
+    }
+  } catch {
+  }
+  return obj;
+}
+function isPromise(obj) {
+  return obj && typeof obj === "object" && typeof obj.then === "function";
+}
+function getAllPropertyKeys(obj) {
+  const keys = [];
+  const ownKeys = Reflect.ownKeys(obj);
+  keys.push(...ownKeys);
+  return keys;
+}
+function safeDeepCopy(obj) {
+  try {
+    const rawObj = getRawReactiveValue(obj);
+    if (rawObj !== obj) {
+      return deepCopys(rawObj, {
+        handleProxy: "unwrap",
+        maxDepth: 50
+      });
+    }
+  } catch (error) {
+  }
+  return deepCopys(obj, {
+    handleProxy: "unwrap",
+    maxDepth: 50
+  });
+}
+function getRawReactiveValue(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  try {
+    const raw = obj.__v_raw;
+    if (raw !== void 0) {
+      return raw;
+    }
+  } catch {
+  }
+  try {
+    if (obj.__ob__) {
+      const plainObj = { ...obj };
+      delete plainObj.__ob__;
+      return plainObj;
+    }
+  } catch {
+  }
+  return obj;
+}
+function fastDeepCopy(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (e) {
+    console.warn("fastDeepCopy failed, falling back to deepCopys", e);
+    return deepCopys(obj, {
+      handleProxy: "unwrap",
+      maxDepth: 100
+    });
+  }
+}
+function structuredCloneCopy(obj) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(obj);
+    } catch (e) {
+      console.warn(
+        "structuredClone failed, falling back to deepCopys",
+        e
+      );
+      return deepCopys(obj);
+    }
+  }
+  return deepCopys(obj);
+}
+function isPlainObject(obj) {
+  return obj !== null && typeof obj === "object" && obj.constructor === Object;
+}
+function simpleDeepCopy(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => simpleDeepCopy(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  const copy = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      copy[key] = simpleDeepCopy(obj[key]);
+    }
+  }
+  return copy;
+}
+
+export {
+  deepCopys,
+  safeDeepCopy,
+  fastDeepCopy,
+  structuredCloneCopy,
+  isPlainObject,
+  simpleDeepCopy
+};

package/dist/{index-BHI-3z9i.d.cts → index-Cz8fWd5l.d.cts}

@@ -1,5 +1,6 @@
 import { attrValueSort } from './basic/object/attrValueSort.cjs';
 import { deepCopy } from './basic/object/deepCopy.cjs';
+import { deepCopys, fastDeepCopy, isPlainObject, safeDeepCopy, simpleDeepCopy, structuredCloneCopy } from './basic/object/deepCopys.cjs';
 import { filterObject } from './basic/object/filterObject.cjs';
 import { getSort } from './basic/object/getSort.cjs';
 import { hasOwn } from './basic/object/hasOwn.cjs';
@@ -14,6 +15,8 @@ import { unmergeObject } from './basic/object/unmergeObject.cjs';
 
 declare const index_attrValueSort: typeof attrValueSort;
 declare const index_deepCopy: typeof deepCopy;
+declare const index_deepCopys: typeof deepCopys;
+declare const index_fastDeepCopy: typeof fastDeepCopy;
 declare const index_filterObject: typeof filterObject;
 declare const index_getObjValue: typeof getObjValue;
 declare const index_getSort: typeof getSort;
@@ -22,13 +25,17 @@ declare const index_isEqual: typeof isEqual;
 declare const index_isEqualEnhanced: typeof isEqualEnhanced;
 declare const index_isObject: typeof isObject;
 declare const index_isObjectArray: typeof isObjectArray;
+declare const index_isPlainObject: typeof isPlainObject;
 declare const index_mergeObject: typeof mergeObject;
 declare const index_reverseObj: typeof reverseObj;
+declare const index_safeDeepCopy: typeof safeDeepCopy;
 declare const index_setObjValue: typeof setObjValue;
 declare const index_setSort: typeof setSort;
+declare const index_simpleDeepCopy: typeof simpleDeepCopy;
+declare const index_structuredCloneCopy: typeof structuredCloneCopy;
 declare const index_unmergeObject: typeof unmergeObject;
 declare namespace index {
-  export { index_attrValueSort as attrValueSort, index_deepCopy as deepCopy, index_filterObject as filterObject, index_getObjValue as getObjValue, index_getSort as getSort, index_hasOwn as hasOwn, index_isEqual as isEqual, index_isEqualEnhanced as isEqualEnhanced, index_isObject as isObject, index_isObjectArray as isObjectArray, index_mergeObject as mergeObject, index_reverseObj as reverseObj, index_setObjValue as setObjValue, index_setSort as setSort, index_unmergeObject as unmergeObject };
+  export { index_attrValueSort as attrValueSort, index_deepCopy as deepCopy, index_deepCopys as deepCopys, index_fastDeepCopy as fastDeepCopy, index_filterObject as filterObject, index_getObjValue as getObjValue, index_getSort as getSort, index_hasOwn as hasOwn, index_isEqual as isEqual, index_isEqualEnhanced as isEqualEnhanced, index_isObject as isObject, index_isObjectArray as isObjectArray, index_isPlainObject as isPlainObject, index_mergeObject as mergeObject, index_reverseObj as reverseObj, index_safeDeepCopy as safeDeepCopy, index_setObjValue as setObjValue, index_setSort as setSort, index_simpleDeepCopy as simpleDeepCopy, index_structuredCloneCopy as structuredCloneCopy, index_unmergeObject as unmergeObject };
 }
 
 export { index as i };

package/dist/{index-C6fjPfzn.d.ts → index-J-xiEtN9.d.ts}

@@ -1,5 +1,5 @@
 import { i as index$1 } from './index-BYfEDFkm.js';
-import { i as index$2 } from './index-qKkaUBR7.js';
+import { i as index$2 } from './index-oW2flHUo.js';
 import { i as index$3 } from './index-BsactE-d.js';
 
 declare namespace index {