@ztimson/utils 0.26.1 → 0.26.3

package/dist/database.d.ts

@@ -33,7 +33,7 @@ export declare class Table<K extends IDBValidKey = any, T = any> {
     get(key: K): Promise<T>;
     getAll(): Promise<T[]>;
     getAllKeys(): Promise<K[]>;
-    put(key: K, value: T): Promise<void>;
+    put(value: T, key?: string): Promise<void>;
     read(): Promise<T[]>;
     read(key: K): Promise<T>;
     set(value: T, key?: K): Promise<void>;

package/dist/index.cjs

@@ -199,13 +199,34 @@ ${opts.message || this.desc}`;
     if (type == "function") return target.toString() == values.toString();
     return target == values;
   }
-  function isEqual(a, b) {
-    const ta = typeof a, tb = typeof b;
-    if (ta != "object" || a == null || (tb != "object" || b == null))
-      return ta == "function" && tb == "function" ? a.toString() == b.toString() : a === b;
-    const keys = Object.keys(a);
-    if (keys.length != Object.keys(b).length) return false;
-    return Object.keys(a).every((key) => isEqual(a[key], b[key]));
+  function isEqual(a, b, seen = /* @__PURE__ */ new WeakMap()) {
+    if (a === b) return true;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+    if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+      if (Number.isNaN(a) && Number.isNaN(b)) return true;
+      if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+      return false;
+    }
+    if (seen.has(a)) return seen.get(a) === b;
+    seen.set(a, b);
+    const isArrayA = Array.isArray(a);
+    const isArrayB = Array.isArray(b);
+    if (isArrayA && isArrayB) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i], seen)) return false;
+      }
+      return true;
+    }
+    if (isArrayA !== isArrayB) return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key], seen)) return false;
+    }
+    return true;
   }
   function mixin(target, constructors) {
     constructors.forEach((c) => {
@@ -1124,15 +1145,19 @@ ${opts.message || this.desc}`;
     getAllKeys() {
       return this.tx(this.name, (store) => store.getAllKeys(), true);
     }
-    put(key, value) {
-      return this.tx(this.name, (store) => store.put(value, key));
+    put(value, key) {
+      return this.tx(this.name, (store) => {
+        if (store.keyPath) return store.put(value);
+        return store.put(value, key);
+      });
     }
     read(key) {
       return key ? this.get(key) : this.getAll();
     }
     set(value, key) {
-      if (!key && !value[this.key]) return this.add(value);
-      return this.put(key || value[this.key], value);
+      if (key) value[this.key] = key;
+      if (!value[this.key]) return this.add(value);
+      return this.put(value);
     }
   }
   class PromiseProgress extends Promise {
@@ -1723,7 +1748,7 @@ ${opts.message || this.desc}`;
   }
   class PathError extends Error {
   }
-  class PathEvent {
+  const _PathEvent = class _PathEvent {
     constructor(e) {
       /** First directory in path */
       __publicField(this, "module");
@@ -1735,7 +1760,14 @@ ${opts.message || this.desc}`;
       __publicField(this, "name");
       /** List of methods */
       __publicField(this, "methods");
-      if (typeof e == "object") return Object.assign(this, e);
+      if (typeof e == "object") {
+        Object.assign(this, e);
+        return;
+      }
+      if (_PathEvent.pathEventCache.has(e)) {
+        Object.assign(this, _PathEvent.pathEventCache.get(e));
+        return;
+      }
       let [p, scope, method] = e.replaceAll(/\/{2,}/g, "/").split(":");
       if (!method) method = scope || "*";
       if (p == "*" || !p && method == "*") {
@@ -1748,13 +1780,14 @@ ${opts.message || this.desc}`;
       this.fullPath = `${this.module}${this.module && this.path ? "/" : ""}${this.path}`;
       this.name = temp.pop() || "";
       this.methods = new ASet(method.split(""));
+      _PathEvent.pathEventCache.set(e, this);
     }
     /** All/Wildcard specified */
     get all() {
       return this.methods.has("*");
     }
     set all(v) {
-      v ? new ASet(["*"]) : this.methods.delete("*");
+      v ? this.methods = new ASet(["*"]) : this.methods.delete("*");
     }
     /** None specified */
     get none() {
@@ -1791,6 +1824,10 @@ ${opts.message || this.desc}`;
     set delete(v) {
       v ? this.methods.delete("n").delete("*").add("d") : this.methods.delete("d");
     }
+    /** Clear the cache of all PathEvents */
+    static clearCache() {
+      _PathEvent.pathEventCache.clear();
+    }
     /**
      * Combine multiple events into one parsed object. Longest path takes precedent, but all subsequent methods are
      * combined until a "none" is reached
@@ -1800,7 +1837,7 @@ ${opts.message || this.desc}`;
      */
     static combine(...paths) {
       let hitNone = false;
-      const combined = paths.map((p) => new PathEvent(p)).toSorted((p1, p2) => {
+      const combined = paths.map((p) => p instanceof _PathEvent ? p : new _PathEvent(p)).toSorted((p1, p2) => {
         const l1 = p1.fullPath.length, l2 = p2.fullPath.length;
         return l1 < l2 ? 1 : l1 > l2 ? -1 : 0;
       }).reduce((acc, p) => {
@@ -1808,10 +1845,9 @@ ${opts.message || this.desc}`;
         if (p.none) hitNone = true;
         if (!acc) return p;
         if (hitNone) return acc;
-        acc.methods = [...acc.methods, ...p.methods];
+        acc.methods = new ASet([...acc.methods, ...p.methods]);
         return acc;
       }, null);
-      combined.methods = new ASet(combined.methods);
       return combined;
     }
     /**
@@ -1822,11 +1858,12 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     static filter(target, ...filter) {
-      const parsedTarget = makeArray(target).map((pe) => new PathEvent(pe));
-      const parsedFilter = makeArray(filter).map((pe) => new PathEvent(pe));
+      const parsedTarget = makeArray(target).map((pe) => pe instanceof _PathEvent ? pe : new _PathEvent(pe));
+      const parsedFilter = makeArray(filter).map((pe) => pe instanceof _PathEvent ? pe : new _PathEvent(pe));
       return parsedTarget.filter((t) => !!parsedFilter.find((r) => {
         const wildcard = r.fullPath == "*" || t.fullPath == "*";
-        const p1 = r.fullPath.slice(0, r.fullPath.indexOf("*")), p2 = t.fullPath.slice(0, t.fullPath.indexOf("*"));
+        const p1 = r.fullPath.includes("*") ? r.fullPath.slice(0, r.fullPath.indexOf("*")) : r.fullPath;
+        const p2 = t.fullPath.includes("*") ? t.fullPath.slice(0, t.fullPath.indexOf("*")) : t.fullPath;
         const scope = p1.startsWith(p2) || p2.startsWith(p1);
         const methods = r.all || t.all || r.methods.intersection(t.methods).length;
         return (wildcard || scope) && methods;
@@ -1840,11 +1877,12 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     static has(target, ...has) {
-      const parsedTarget = makeArray(target).map((pe) => new PathEvent(pe));
-      const parsedRequired = makeArray(has).map((pe) => new PathEvent(pe));
+      const parsedTarget = makeArray(target).map((pe) => pe instanceof _PathEvent ? pe : new _PathEvent(pe));
+      const parsedRequired = makeArray(has).map((pe) => pe instanceof _PathEvent ? pe : new _PathEvent(pe));
       return !!parsedRequired.find((r) => !!parsedTarget.find((t) => {
         const wildcard = r.fullPath == "*" || t.fullPath == "*";
-        const p1 = r.fullPath.slice(0, r.fullPath.indexOf("*")), p2 = t.fullPath.slice(0, t.fullPath.indexOf("*"));
+        const p1 = r.fullPath.includes("*") ? r.fullPath.slice(0, r.fullPath.indexOf("*")) : r.fullPath;
+        const p2 = t.fullPath.includes("*") ? t.fullPath.slice(0, t.fullPath.indexOf("*")) : t.fullPath;
         const scope = p1.startsWith(p2);
         const methods = r.all || t.all || r.methods.intersection(t.methods).length;
         return (wildcard || scope) && methods;
@@ -1858,7 +1896,7 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     static hasAll(target, ...has) {
-      return has.filter((h) => PathEvent.has(target, h)).length == has.length;
+      return has.filter((h) => _PathEvent.has(target, h)).length == has.length;
     }
     /**
      * Same as `has` but raises an error if there is no overlap
@@ -1867,7 +1905,7 @@ ${opts.message || this.desc}`;
      * @param has Target must have at least one of these path
      */
     static hasFatal(target, ...has) {
-      if (!PathEvent.has(target, ...has)) throw new PathError(`Requires one of: ${makeArray(has).join(", ")}`);
+      if (!_PathEvent.has(target, ...has)) throw new PathError(`Requires one of: ${makeArray(has).join(", ")}`);
     }
     /**
      * Same as `hasAll` but raises an error if the target is missing any paths
@@ -1876,7 +1914,7 @@ ${opts.message || this.desc}`;
      * @param has Target must have all these paths
      */
     static hasAllFatal(target, ...has) {
-      if (!PathEvent.hasAll(target, ...has)) throw new PathError(`Requires all: ${makeArray(has).join(", ")}`);
+      if (!_PathEvent.hasAll(target, ...has)) throw new PathError(`Requires all: ${makeArray(has).join(", ")}`);
     }
     /**
      * Create event string from its components
@@ -1898,7 +1936,7 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     has(...has) {
-      return PathEvent.has(this, ...has);
+      return _PathEvent.has(this, ...has);
     }
     /**
      * Squash 2 sets of paths & return true if the target has all paths
@@ -1907,7 +1945,7 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     hasAll(...has) {
-      return PathEvent.hasAll(this, ...has);
+      return _PathEvent.hasAll(this, ...has);
     }
     /**
      * Same as `has` but raises an error if there is no overlap
@@ -1915,7 +1953,7 @@ ${opts.message || this.desc}`;
      * @param has Target must have at least one of these path
      */
     hasFatal(...has) {
-      return PathEvent.hasFatal(this, ...has);
+      return _PathEvent.hasFatal(this, ...has);
     }
     /**
      * Same as `hasAll` but raises an error if the target is missing any paths
@@ -1923,7 +1961,7 @@ ${opts.message || this.desc}`;
      * @param has Target must have all these paths
      */
     hasAllFatal(...has) {
-      return PathEvent.hasAllFatal(this, ...has);
+      return _PathEvent.hasAllFatal(this, ...has);
     }
     /**
      * Filter a set of paths based on this event
@@ -1932,7 +1970,7 @@ ${opts.message || this.desc}`;
      * @return {boolean} Whether there is any overlap
      */
     filter(target) {
-      return PathEvent.filter(target, this);
+      return _PathEvent.filter(target, this);
     }
     /**
      * Create event string from its components
@@ -1940,16 +1978,19 @@ ${opts.message || this.desc}`;
      * @return {string} String representation of Event
      */
     toString() {
-      return PathEvent.toString(this.fullPath, this.methods);
+      return _PathEvent.toString(this.fullPath, this.methods);
     }
-  }
+  };
+  /** Internal cache for PathEvent instances to avoid redundant parsing */
+  __publicField(_PathEvent, "pathEventCache", /* @__PURE__ */ new Map());
+  let PathEvent = _PathEvent;
   class PathEventEmitter {
     constructor(prefix = "") {
       __publicField(this, "listeners", []);
       this.prefix = prefix;
     }
     emit(event, ...args) {
-      const parsed = PE`${this.prefix}/${event}`;
+      const parsed = event instanceof PathEvent ? event : new PathEvent(`${this.prefix}/${event}`);
       this.listeners.filter((l) => PathEvent.has(l[0], parsed)).forEach(async (l) => l[1](parsed, ...args));
     }
     off(listener) {
@@ -1957,7 +1998,7 @@ ${opts.message || this.desc}`;
     }
     on(event, listener) {
       makeArray(event).forEach((e) => this.listeners.push([
-        new PathEvent(`${this.prefix}/${e}`),
+        e instanceof PathEvent ? e : new PathEvent(`${this.prefix}/${e}`),
         listener
       ]));
       return () => this.off(listener);