@base-web-kits/base-tools-web 1.2.8 → 1.2.9

package/dist/index.js

@@ -540,8 +540,237 @@ function preloadImage(src) {
   });
 }
 
-// src/web/network/request.ts
-import { cloneDeep, isPlainObject } from "es-toolkit";
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+  if (value == null) {
+    return value === void 0 ? "[object Undefined]" : "[object Null]";
+  }
+  return Object.prototype.toString.call(value);
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag = "[object RegExp]";
+var stringTag = "[object String]";
+var numberTag = "[object Number]";
+var booleanTag = "[object Boolean]";
+var argumentsTag = "[object Arguments]";
+var symbolTag = "[object Symbol]";
+var dateTag = "[object Date]";
+var mapTag = "[object Map]";
+var setTag = "[object Set]";
+var arrayTag = "[object Array]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var objectTag = "[object Object]";
+var dataViewTag = "[object DataView]";
+var uint8ArrayTag = "[object Uint8Array]";
+var uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+var uint16ArrayTag = "[object Uint16Array]";
+var uint32ArrayTag = "[object Uint32Array]";
+var int8ArrayTag = "[object Int8Array]";
+var int16ArrayTag = "[object Int16Array]";
+var int32ArrayTag = "[object Int32Array]";
+var float32ArrayTag = "[object Float32Array]";
+var float64ArrayTag = "[object Float64Array]";
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  const cloned = cloneValue == null ? void 0 : cloneValue(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) {
+    return cloned;
+  }
+  if (isPrimitive(valueToClone)) {
+    return valueToClone;
+  }
+  if (stack.has(valueToClone)) {
+    return stack.get(valueToClone);
+  }
+  if (Array.isArray(valueToClone)) {
+    const result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    if (Object.hasOwn(valueToClone, "index")) {
+      result.index = valueToClone.index;
+    }
+    if (Object.hasOwn(valueToClone, "input")) {
+      result.input = valueToClone.input;
+    }
+    return result;
+  }
+  if (valueToClone instanceof Date) {
+    return new Date(valueToClone.getTime());
+  }
+  if (valueToClone instanceof RegExp) {
+    const result = new RegExp(valueToClone.source, valueToClone.flags);
+    result.lastIndex = valueToClone.lastIndex;
+    return result;
+  }
+  if (valueToClone instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (const [key, value] of valueToClone) {
+      result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (const value of valueToClone) {
+      result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(valueToClone)) {
+    return valueToClone.subarray();
+  }
+  if (isTypedArray(valueToClone)) {
+    const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) {
+    return valueToClone.slice(0);
+  }
+  if (valueToClone instanceof DataView) {
+    const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof File !== "undefined" && valueToClone instanceof File) {
+    const result = new File([valueToClone], valueToClone.name, {
+      type: valueToClone.type
+    });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof Blob !== "undefined" && valueToClone instanceof Blob) {
+    const result = new Blob([valueToClone], { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Error) {
+    const result = new valueToClone.constructor();
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Boolean) {
+    const result = new Boolean(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Number) {
+    const result = new Number(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof String) {
+    const result = new String(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+    const result = Object.create(Object.getPrototypeOf(valueToClone));
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  const keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor == null || descriptor.writable) {
+      target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+    }
+  }
+}
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag: {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
+  if (!hasObjectPrototype) {
+    return false;
+  }
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
 
 // src/ts/day/index.ts
 import dayjs from "dayjs";
@@ -578,8 +807,188 @@ function toDayjs(t, fmt) {
   return dayjs(t, fmt);
 }
 
+// node_modules/.pnpm/es-toolkit@1.44.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.44.0/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs
+function toKey(value) {
+  var _a;
+  if (typeof value === "string" || typeof value === "symbol") {
+    return value;
+  }
+  if (Object.is((_a = value == null ? void 0 : value.valueOf) == null ? void 0 : _a.call(value), -0)) {
+    return "-0";
+  }
+  return String(value);
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.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.44.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.44.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 == null ? void 0 : 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;
+}
+
 // src/ts/object/index.ts
-import { get, set } from "es-toolkit/compat";
 var getObjectValue = get;
 
 // src/ts/url/param/index.ts
@@ -874,7 +1283,6 @@ function toFormData(data) {
 }
 
 // src/web/async/index.ts
-import { cloneDeep as cloneDeep2 } from "es-toolkit";
 function enhanceWebApi(webApi, apiName) {
   return (option, config) => {
     const finalConfig = config || {};
@@ -905,9 +1313,9 @@ function enhanceWebApi(webApi, apiName) {
           const logData = __spreadValues({ name: fname, status: "success", option }, logExtra);
           if (resMap) {
             logData.res = res;
-            logData.resMap = cloneDeep2(finalRes);
+            logData.resMap = cloneDeep(finalRes);
           } else {
-            logData.res = cloneDeep2(res);
+            logData.res = cloneDeep(res);
           }
           log == null ? void 0 : log("info", logData);
         }