@weapp-core/shared 1.0.1 → 1.0.2

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as defu from 'defu';
 export { default as defu } from 'defu';
-export { default as set } from 'set-value';
+export { default as objectHash } from 'object-hash';
 export { default as get } from 'get-value';
+export { default as set } from 'set-value';
 
 declare function escapeStringRegexp(str: string): string;
 declare function removeExtension(file: string): string;

package/dist/index.js

@@ -4,10 +4,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -27,24 +33,389 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@8.2.4_jiti@1.21.6_postcss@8.4.41_tsx@4.17.0_typescript@5.5.4_yaml@2.5.0/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.3.0_jiti@2.2.1_postcss@8.4.47_tsx@4.19.1_typescript@5.6.2_yaml@2.5.1/node_modules/tsup/assets/esm_shims.js
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.2.4_jiti@1.21.6_postcss@8.4.41_tsx@4.17.0_typescript@5.5.4_yaml@2.5.0/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.3.0_jiti@2.2.1_postcss@8.4.47_tsx@4.19.1_typescript@5.6.2_yaml@2.5.1/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
 
-// ../../node_modules/.pnpm/is-primitive@3.0.1/node_modules/is-primitive/index.js
-var require_is_primitive = __commonJS({
-  "../../node_modules/.pnpm/is-primitive@3.0.1/node_modules/is-primitive/index.js"(exports, module) {
+// ../../node_modules/.pnpm/object-hash@3.0.0/node_modules/object-hash/index.js
+var require_object_hash = __commonJS({
+  "../../node_modules/.pnpm/object-hash@3.0.0/node_modules/object-hash/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    module.exports = function isPrimitive(val) {
-      if (typeof val === "object") {
-        return val === null;
+    var crypto = __require("crypto");
+    exports = module.exports = objectHash2;
+    function objectHash2(object, options) {
+      options = applyDefaults(object, options);
+      return hash(object, options);
+    }
+    exports.sha1 = function(object) {
+      return objectHash2(object);
+    };
+    exports.keys = function(object) {
+      return objectHash2(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
+    };
+    exports.MD5 = function(object) {
+      return objectHash2(object, { algorithm: "md5", encoding: "hex" });
+    };
+    exports.keysMD5 = function(object) {
+      return objectHash2(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
+    };
+    var hashes = crypto.getHashes ? crypto.getHashes().slice() : ["sha1", "md5"];
+    hashes.push("passthrough");
+    var encodings = ["buffer", "hex", "binary", "base64"];
+    function applyDefaults(object, sourceOptions) {
+      sourceOptions = sourceOptions || {};
+      var options = {};
+      options.algorithm = sourceOptions.algorithm || "sha1";
+      options.encoding = sourceOptions.encoding || "hex";
+      options.excludeValues = sourceOptions.excludeValues ? true : false;
+      options.algorithm = options.algorithm.toLowerCase();
+      options.encoding = options.encoding.toLowerCase();
+      options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
+      options.respectType = sourceOptions.respectType === false ? false : true;
+      options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+      options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+      options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
+      options.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
+      options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
+      options.replacer = sourceOptions.replacer || void 0;
+      options.excludeKeys = sourceOptions.excludeKeys || void 0;
+      if (typeof object === "undefined") {
+        throw new Error("Object argument required.");
       }
-      return typeof val !== "function";
+      for (var i = 0; i < hashes.length; ++i) {
+        if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
+          options.algorithm = hashes[i];
+        }
+      }
+      if (hashes.indexOf(options.algorithm) === -1) {
+        throw new Error('Algorithm "' + options.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
+      }
+      if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== "passthrough") {
+        throw new Error('Encoding "' + options.encoding + '"  not supported. supported values: ' + encodings.join(", "));
+      }
+      return options;
+    }
+    function isNativeFunction(f) {
+      if (typeof f !== "function") {
+        return false;
+      }
+      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+      return exp.exec(Function.prototype.toString.call(f)) != null;
+    }
+    function hash(object, options) {
+      var hashingStream;
+      if (options.algorithm !== "passthrough") {
+        hashingStream = crypto.createHash(options.algorithm);
+      } else {
+        hashingStream = new PassThrough();
+      }
+      if (typeof hashingStream.write === "undefined") {
+        hashingStream.write = hashingStream.update;
+        hashingStream.end = hashingStream.update;
+      }
+      var hasher = typeHasher(options, hashingStream);
+      hasher.dispatch(object);
+      if (!hashingStream.update) {
+        hashingStream.end("");
+      }
+      if (hashingStream.digest) {
+        return hashingStream.digest(options.encoding === "buffer" ? void 0 : options.encoding);
+      }
+      var buf = hashingStream.read();
+      if (options.encoding === "buffer") {
+        return buf;
+      }
+      return buf.toString(options.encoding);
+    }
+    exports.writeToStream = function(object, options, stream) {
+      if (typeof stream === "undefined") {
+        stream = options;
+        options = {};
+      }
+      options = applyDefaults(object, options);
+      return typeHasher(options, stream).dispatch(object);
     };
+    function typeHasher(options, writeTo, context) {
+      context = context || [];
+      var write = function(str) {
+        if (writeTo.update) {
+          return writeTo.update(str, "utf8");
+        } else {
+          return writeTo.write(str, "utf8");
+        }
+      };
+      return {
+        dispatch: function(value) {
+          if (options.replacer) {
+            value = options.replacer(value);
+          }
+          var type = typeof value;
+          if (value === null) {
+            type = "null";
+          }
+          return this["_" + type](value);
+        },
+        _object: function(object) {
+          var pattern = /\[object (.*)\]/i;
+          var objString = Object.prototype.toString.call(object);
+          var objType = pattern.exec(objString);
+          if (!objType) {
+            objType = "unknown:[" + objString + "]";
+          } else {
+            objType = objType[1];
+          }
+          objType = objType.toLowerCase();
+          var objectNumber = null;
+          if ((objectNumber = context.indexOf(object)) >= 0) {
+            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+          } else {
+            context.push(object);
+          }
+          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+            write("buffer:");
+            return write(object);
+          }
+          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+            if (this["_" + objType]) {
+              this["_" + objType](object);
+            } else if (options.ignoreUnknown) {
+              return write("[" + objType + "]");
+            } else {
+              throw new Error('Unknown object type "' + objType + '"');
+            }
+          } else {
+            var keys = Object.keys(object);
+            if (options.unorderedObjects) {
+              keys = keys.sort();
+            }
+            if (options.respectType !== false && !isNativeFunction(object)) {
+              keys.splice(0, 0, "prototype", "__proto__", "constructor");
+            }
+            if (options.excludeKeys) {
+              keys = keys.filter(function(key) {
+                return !options.excludeKeys(key);
+              });
+            }
+            write("object:" + keys.length + ":");
+            var self = this;
+            return keys.forEach(function(key) {
+              self.dispatch(key);
+              write(":");
+              if (!options.excludeValues) {
+                self.dispatch(object[key]);
+              }
+              write(",");
+            });
+          }
+        },
+        _array: function(arr, unordered) {
+          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+          var self = this;
+          write("array:" + arr.length + ":");
+          if (!unordered || arr.length <= 1) {
+            return arr.forEach(function(entry) {
+              return self.dispatch(entry);
+            });
+          }
+          var contextAdditions = [];
+          var entries = arr.map(function(entry) {
+            var strm = new PassThrough();
+            var localContext = context.slice();
+            var hasher = typeHasher(options, strm, localContext);
+            hasher.dispatch(entry);
+            contextAdditions = contextAdditions.concat(localContext.slice(context.length));
+            return strm.read().toString();
+          });
+          context = context.concat(contextAdditions);
+          entries.sort();
+          return this._array(entries, false);
+        },
+        _date: function(date) {
+          return write("date:" + date.toJSON());
+        },
+        _symbol: function(sym) {
+          return write("symbol:" + sym.toString());
+        },
+        _error: function(err) {
+          return write("error:" + err.toString());
+        },
+        _boolean: function(bool) {
+          return write("bool:" + bool.toString());
+        },
+        _string: function(string) {
+          write("string:" + string.length + ":");
+          write(string.toString());
+        },
+        _function: function(fn) {
+          write("fn:");
+          if (isNativeFunction(fn)) {
+            this.dispatch("[native]");
+          } else {
+            this.dispatch(fn.toString());
+          }
+          if (options.respectFunctionNames !== false) {
+            this.dispatch("function-name:" + String(fn.name));
+          }
+          if (options.respectFunctionProperties) {
+            this._object(fn);
+          }
+        },
+        _number: function(number) {
+          return write("number:" + number.toString());
+        },
+        _xml: function(xml) {
+          return write("xml:" + xml.toString());
+        },
+        _null: function() {
+          return write("Null");
+        },
+        _undefined: function() {
+          return write("Undefined");
+        },
+        _regexp: function(regex) {
+          return write("regex:" + regex.toString());
+        },
+        _uint8array: function(arr) {
+          write("uint8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint8clampedarray: function(arr) {
+          write("uint8clampedarray:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int8array: function(arr) {
+          write("int8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint16array: function(arr) {
+          write("uint16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int16array: function(arr) {
+          write("int16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint32array: function(arr) {
+          write("uint32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int32array: function(arr) {
+          write("int32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float32array: function(arr) {
+          write("float32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float64array: function(arr) {
+          write("float64array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _arraybuffer: function(arr) {
+          write("arraybuffer:");
+          return this.dispatch(new Uint8Array(arr));
+        },
+        _url: function(url) {
+          return write("url:" + url.toString(), "utf8");
+        },
+        _map: function(map) {
+          write("map:");
+          var arr = Array.from(map);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _set: function(set) {
+          write("set:");
+          var arr = Array.from(set);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _file: function(file) {
+          write("file:");
+          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+        },
+        _blob: function() {
+          if (options.ignoreUnknown) {
+            return write("[blob]");
+          }
+          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
+        },
+        _domwindow: function() {
+          return write("domwindow");
+        },
+        _bigint: function(number) {
+          return write("bigint:" + number.toString());
+        },
+        /* Node.js standard native objects */
+        _process: function() {
+          return write("process");
+        },
+        _timer: function() {
+          return write("timer");
+        },
+        _pipe: function() {
+          return write("pipe");
+        },
+        _tcp: function() {
+          return write("tcp");
+        },
+        _udp: function() {
+          return write("udp");
+        },
+        _tty: function() {
+          return write("tty");
+        },
+        _statwatcher: function() {
+          return write("statwatcher");
+        },
+        _securecontext: function() {
+          return write("securecontext");
+        },
+        _connection: function() {
+          return write("connection");
+        },
+        _zlib: function() {
+          return write("zlib");
+        },
+        _context: function() {
+          return write("context");
+        },
+        _nodescript: function() {
+          return write("nodescript");
+        },
+        _httpparser: function() {
+          return write("httpparser");
+        },
+        _dataview: function() {
+          return write("dataview");
+        },
+        _signal: function() {
+          return write("signal");
+        },
+        _fsevent: function() {
+          return write("fsevent");
+        },
+        _tlswrap: function() {
+          return write("tlswrap");
+        }
+      };
+    }
+    function PassThrough() {
+      return {
+        buf: "",
+        write: function(b) {
+          this.buf += b;
+        },
+        end: function(b) {
+          this.buf += b;
+        },
+        read: function() {
+          return this.buf;
+        }
+      };
+    }
   }
 });
 
@@ -59,6 +430,110 @@ var require_isobject = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/get-value@3.0.1/node_modules/get-value/index.js
+var require_get_value = __commonJS({
+  "../../node_modules/.pnpm/get-value@3.0.1/node_modules/get-value/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var isObject2 = require_isobject();
+    module.exports = function(target, path, options) {
+      if (!isObject2(options)) {
+        options = { default: options };
+      }
+      if (!isValidObject(target)) {
+        return typeof options.default !== "undefined" ? options.default : target;
+      }
+      if (typeof path === "number") {
+        path = String(path);
+      }
+      const isArray = Array.isArray(path);
+      const isString = typeof path === "string";
+      const splitChar = options.separator || ".";
+      const joinChar = options.joinChar || (typeof splitChar === "string" ? splitChar : ".");
+      if (!isString && !isArray) {
+        return target;
+      }
+      if (isString && path in target) {
+        return isValid(path, target, options) ? target[path] : options.default;
+      }
+      let segs = isArray ? path : split(path, splitChar, options);
+      let len = segs.length;
+      let idx = 0;
+      do {
+        let prop = segs[idx];
+        if (typeof prop === "number") {
+          prop = String(prop);
+        }
+        while (prop && prop.slice(-1) === "\\") {
+          prop = join([prop.slice(0, -1), segs[++idx] || ""], joinChar, options);
+        }
+        if (prop in target) {
+          if (!isValid(prop, target, options)) {
+            return options.default;
+          }
+          target = target[prop];
+        } else {
+          let hasProp = false;
+          let n = idx + 1;
+          while (n < len) {
+            prop = join([prop, segs[n++]], joinChar, options);
+            if (hasProp = prop in target) {
+              if (!isValid(prop, target, options)) {
+                return options.default;
+              }
+              target = target[prop];
+              idx = n - 1;
+              break;
+            }
+          }
+          if (!hasProp) {
+            return options.default;
+          }
+        }
+      } while (++idx < len && isValidObject(target));
+      if (idx === len) {
+        return target;
+      }
+      return options.default;
+    };
+    function join(segs, joinChar, options) {
+      if (typeof options.join === "function") {
+        return options.join(segs);
+      }
+      return segs[0] + joinChar + segs[1];
+    }
+    function split(path, splitChar, options) {
+      if (typeof options.split === "function") {
+        return options.split(path);
+      }
+      return path.split(splitChar);
+    }
+    function isValid(key, target, options) {
+      if (typeof options.isValid === "function") {
+        return options.isValid(key, target);
+      }
+      return true;
+    }
+    function isValidObject(val) {
+      return isObject2(val) || Array.isArray(val) || typeof val === "function";
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/is-primitive@3.0.1/node_modules/is-primitive/index.js
+var require_is_primitive = __commonJS({
+  "../../node_modules/.pnpm/is-primitive@3.0.1/node_modules/is-primitive/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = function isPrimitive(val) {
+      if (typeof val === "object") {
+        return val === null;
+      }
+      return typeof val !== "function";
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js
 var require_is_plain_object = __commonJS({
   "../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js"(exports, module) {
@@ -213,96 +688,6 @@ var require_set_value = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/get-value@3.0.1/node_modules/get-value/index.js
-var require_get_value = __commonJS({
-  "../../node_modules/.pnpm/get-value@3.0.1/node_modules/get-value/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var isObject2 = require_isobject();
-    module.exports = function(target, path, options) {
-      if (!isObject2(options)) {
-        options = { default: options };
-      }
-      if (!isValidObject(target)) {
-        return typeof options.default !== "undefined" ? options.default : target;
-      }
-      if (typeof path === "number") {
-        path = String(path);
-      }
-      const isArray = Array.isArray(path);
-      const isString = typeof path === "string";
-      const splitChar = options.separator || ".";
-      const joinChar = options.joinChar || (typeof splitChar === "string" ? splitChar : ".");
-      if (!isString && !isArray) {
-        return target;
-      }
-      if (isString && path in target) {
-        return isValid(path, target, options) ? target[path] : options.default;
-      }
-      let segs = isArray ? path : split(path, splitChar, options);
-      let len = segs.length;
-      let idx = 0;
-      do {
-        let prop = segs[idx];
-        if (typeof prop === "number") {
-          prop = String(prop);
-        }
-        while (prop && prop.slice(-1) === "\\") {
-          prop = join([prop.slice(0, -1), segs[++idx] || ""], joinChar, options);
-        }
-        if (prop in target) {
-          if (!isValid(prop, target, options)) {
-            return options.default;
-          }
-          target = target[prop];
-        } else {
-          let hasProp = false;
-          let n = idx + 1;
-          while (n < len) {
-            prop = join([prop, segs[n++]], joinChar, options);
-            if (hasProp = prop in target) {
-              if (!isValid(prop, target, options)) {
-                return options.default;
-              }
-              target = target[prop];
-              idx = n - 1;
-              break;
-            }
-          }
-          if (!hasProp) {
-            return options.default;
-          }
-        }
-      } while (++idx < len && isValidObject(target));
-      if (idx === len) {
-        return target;
-      }
-      return options.default;
-    };
-    function join(segs, joinChar, options) {
-      if (typeof options.join === "function") {
-        return options.join(segs);
-      }
-      return segs[0] + joinChar + segs[1];
-    }
-    function split(path, splitChar, options) {
-      if (typeof options.split === "function") {
-        return options.split(path);
-      }
-      return path.split(splitChar);
-    }
-    function isValid(key, target, options) {
-      if (typeof options.isValid === "function") {
-        return options.isValid(key, target);
-      }
-      return true;
-    }
-    function isValidObject(val) {
-      return isObject2(val) || Array.isArray(val) || typeof val === "function";
-    }
-  }
-});
-
 // src/index.ts
 init_esm_shims();
 import { extname } from "node:path";
@@ -377,8 +762,9 @@ var defuArrayFn = createDefu((object, key, currentValue) => {
 });
 
 // src/index.ts
-var import_set_value = __toESM(require_set_value(), 1);
+var import_object_hash = __toESM(require_object_hash(), 1);
 var import_get_value = __toESM(require_get_value(), 1);
+var import_set_value = __toESM(require_set_value(), 1);
 function escapeStringRegexp(str) {
   return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
 }
@@ -405,6 +791,7 @@ function isObject(x) {
   return typeof x === "object" && x !== null;
 }
 var export_get = import_get_value.default;
+var export_objectHash = import_object_hash.default;
 var export_set = import_set_value.default;
 export {
   addExtension,
@@ -414,24 +801,33 @@ export {
   escapeStringRegexp,
   export_get as get,
   isObject,
+  export_objectHash as objectHash,
   removeExtension,
   export_set as set
 };
 /*! Bundled license information:
 
-is-primitive/index.js:
+isobject/index.js:
   (*!
-   * is-primitive <https://github.com/jonschlinkert/is-primitive>
+   * isobject <https://github.com/jonschlinkert/isobject>
    *
-   * Copyright (c) 2014-present, Jon Schlinkert.
+   * Copyright (c) 2014-2017, Jon Schlinkert.
    * Released under the MIT License.
    *)
 
-isobject/index.js:
+get-value/index.js:
   (*!
-   * isobject <https://github.com/jonschlinkert/isobject>
+   * get-value <https://github.com/jonschlinkert/get-value>
    *
-   * Copyright (c) 2014-2017, Jon Schlinkert.
+   * Copyright (c) 2014-2018, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+is-primitive/index.js:
+  (*!
+   * is-primitive <https://github.com/jonschlinkert/is-primitive>
+   *
+   * Copyright (c) 2014-present, Jon Schlinkert.
    * Released under the MIT License.
    *)
 
@@ -450,12 +846,4 @@ set-value/index.js:
    * Copyright (c) Jon Schlinkert (https://github.com/jonschlinkert).
    * Released under the MIT License.
    *)
-
-get-value/index.js:
-  (*!
-   * get-value <https://github.com/jonschlinkert/get-value>
-   *
-   * Copyright (c) 2014-2018, Jon Schlinkert.
-   * Released under the MIT License.
-   *)
 */