@base-web-kits/base-tools-ts 0.9.99 → 1.0.1

package/dist/base-tools-ts.umd.global.js

@@ -779,6 +779,7 @@ var baseToolsTS = (() => {
     getOSSImg: () => getOSSImg,
     getOSSVideo: () => getOSSVideo,
     getObjectKeys: () => getObjectKeys,
+    getObjectValue: () => getObjectValue,
     getQnAudio: () => getQnAudio,
     getQnHls: () => getQnHls,
     getQnImg: () => getQnImg,
@@ -913,6 +914,7 @@ var baseToolsTS = (() => {
     round: () => round,
     sample: () => sample,
     sampleSize: () => sampleSize,
+    setObjectValue: () => setObjectValue,
     shuffle: () => shuffle,
     snakeCase: () => snakeCase,
     sortBy: () => sortBy,
@@ -5071,10 +5073,273 @@ var baseToolsTS = (() => {
     throw message;
   }
 
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.mjs
+  function isDeepKey(key) {
+    switch (typeof key) {
+      case "number":
+      case "symbol": {
+        return false;
+      }
+      case "string": {
+        return key.includes(".") || key.includes("[") || key.includes("]");
+      }
+    }
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs
+  function toKey(value) {
+    if (typeof value === "string" || typeof value === "symbol") {
+      return value;
+    }
+    if (Object.is(value?.valueOf?.(), -0)) {
+      return "-0";
+    }
+    return String(value);
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/util/toString.mjs
+  function toString(value) {
+    if (value == null) {
+      return "";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map(toString).join(",");
+    }
+    const result = String(value);
+    if (result === "0" && Object.is(Number(value), -0)) {
+      return "-0";
+    }
+    return result;
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/util/toPath.mjs
+  function toPath(deepKey) {
+    if (Array.isArray(deepKey)) {
+      return deepKey.map(toKey);
+    }
+    if (typeof deepKey === "symbol") {
+      return [deepKey];
+    }
+    deepKey = toString(deepKey);
+    const result = [];
+    const length = deepKey.length;
+    if (length === 0) {
+      return result;
+    }
+    let index = 0;
+    let key = "";
+    let quoteChar = "";
+    let bracket = false;
+    if (deepKey.charCodeAt(0) === 46) {
+      result.push("");
+      index++;
+    }
+    while (index < length) {
+      const char = deepKey[index];
+      if (quoteChar) {
+        if (char === "\\" && index + 1 < length) {
+          index++;
+          key += deepKey[index];
+        } else if (char === quoteChar) {
+          quoteChar = "";
+        } else {
+          key += char;
+        }
+      } else if (bracket) {
+        if (char === '"' || char === "'") {
+          quoteChar = char;
+        } else if (char === "]") {
+          bracket = false;
+          result.push(key);
+          key = "";
+        } else {
+          key += char;
+        }
+      } else {
+        if (char === "[") {
+          bracket = true;
+          if (key) {
+            result.push(key);
+            key = "";
+          }
+        } else if (char === ".") {
+          if (key) {
+            result.push(key);
+            key = "";
+          }
+        } else {
+          key += char;
+        }
+      }
+      index++;
+    }
+    if (key) {
+      result.push(key);
+    }
+    return result;
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/object/get.mjs
+  function get(object, path, defaultValue) {
+    if (object == null) {
+      return defaultValue;
+    }
+    switch (typeof path) {
+      case "string": {
+        if (isUnsafeProperty(path)) {
+          return defaultValue;
+        }
+        const result = object[path];
+        if (result === void 0) {
+          if (isDeepKey(path)) {
+            return get(object, toPath(path), defaultValue);
+          } else {
+            return defaultValue;
+          }
+        }
+        return result;
+      }
+      case "number":
+      case "symbol": {
+        if (typeof path === "number") {
+          path = toKey(path);
+        }
+        const result = object[path];
+        if (result === void 0) {
+          return defaultValue;
+        }
+        return result;
+      }
+      default: {
+        if (Array.isArray(path)) {
+          return getWithPath(object, path, defaultValue);
+        }
+        if (Object.is(path?.valueOf(), -0)) {
+          path = "-0";
+        } else {
+          path = String(path);
+        }
+        if (isUnsafeProperty(path)) {
+          return defaultValue;
+        }
+        const result = object[path];
+        if (result === void 0) {
+          return defaultValue;
+        }
+        return result;
+      }
+    }
+  }
+  function getWithPath(object, path, defaultValue) {
+    if (path.length === 0) {
+      return defaultValue;
+    }
+    let current = object;
+    for (let index = 0; index < path.length; index++) {
+      if (current == null) {
+        return defaultValue;
+      }
+      if (isUnsafeProperty(path[index])) {
+        return defaultValue;
+      }
+      current = current[path[index]];
+    }
+    if (current === void 0) {
+      return defaultValue;
+    }
+    return current;
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/predicate/isObject.mjs
+  function isObject(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function");
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/_internal/isIndex.mjs
+  var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+  function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
+    switch (typeof value) {
+      case "number": {
+        return Number.isInteger(value) && value >= 0 && value < length;
+      }
+      case "symbol": {
+        return false;
+      }
+      case "string": {
+        return IS_UNSIGNED_INTEGER.test(value);
+      }
+    }
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/_internal/isKey.mjs
+  var regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+  var regexIsPlainProp = /^\w*$/;
+  function isKey(value, object) {
+    if (Array.isArray(value)) {
+      return false;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || value == null || isSymbol(value)) {
+      return true;
+    }
+    return typeof value === "string" && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value)) || object != null && Object.hasOwn(object, value);
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/_internal/assignValue.mjs
+  var assignValue = (object, key, value) => {
+    const objValue = object[key];
+    if (!(Object.hasOwn(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+      object[key] = value;
+    }
+  };
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/object/updateWith.mjs
+  function updateWith(obj, path, updater, customizer) {
+    if (obj == null && !isObject(obj)) {
+      return obj;
+    }
+    let resolvedPath;
+    if (isKey(path, obj)) {
+      resolvedPath = [path];
+    } else if (Array.isArray(path)) {
+      resolvedPath = path;
+    } else {
+      resolvedPath = toPath(path);
+    }
+    const updateValue = updater(get(obj, resolvedPath));
+    let current = obj;
+    for (let i = 0; i < resolvedPath.length && current != null; i++) {
+      const key = toKey(resolvedPath[i]);
+      if (isUnsafeProperty(key)) {
+        continue;
+      }
+      let newValue;
+      if (i === resolvedPath.length - 1) {
+        newValue = updateValue;
+      } else {
+        const objValue = current[key];
+        const customizerResult = customizer?.(objValue, key, obj);
+        newValue = customizerResult !== void 0 ? customizerResult : isObject(objValue) ? objValue : isIndex(resolvedPath[i + 1]) ? [] : {};
+      }
+      assignValue(current, key, newValue);
+      current = current[key];
+    }
+    return obj;
+  }
+
+  // node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/compat/object/set.mjs
+  function set(obj, path, value) {
+    return updateWith(obj, path, () => value, () => void 0);
+  }
+
   // src/ts/object/index.ts
   function getObjectKeys(obj) {
     return Object.keys(obj);
   }
+  var getObjectValue = get;
+  var setObjectValue = set;
 
   // src/ts/string/format.ts
   function toMaskText(s, keepLeft = 1, keepRight = 0, maskChar = "*") {