@ztimson/utils 0.26.0 → 0.26.2

package/dist/index.mjs

@@ -195,13 +195,34 @@ function includes(target, values, allowMissing = false) {
   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) => {
@@ -456,7 +477,7 @@ class Cache {
     const persists = this.options.persistentStorage;
     if (!!(persists == null ? void 0 : persists.storage)) {
       if (((_a = persists.storage) == null ? void 0 : _a.constructor.name) == "Database") {
-        persists.storage.createTable({ name: persists.storage.key, key: this.key }).then((table) => {
+        persists.storage.createTable({ name: persists.key, key: this.key }).then((table) => {
           if (key) {
             table.set(key, this.get(key));
           } else {
@@ -1719,7 +1740,7 @@ function PES(str, ...args) {
 }
 class PathError extends Error {
 }
-class PathEvent {
+const _PathEvent = class _PathEvent {
   constructor(e) {
     /** First directory in path */
     __publicField(this, "module");
@@ -1731,7 +1752,14 @@ class PathEvent {
     __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 == "*") {
@@ -1744,13 +1772,14 @@ class PathEvent {
     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() {
@@ -1787,6 +1816,10 @@ class PathEvent {
   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
@@ -1796,7 +1829,7 @@ class PathEvent {
    */
   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) => {
@@ -1804,10 +1837,9 @@ class PathEvent {
       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;
   }
   /**
@@ -1818,11 +1850,12 @@ class PathEvent {
    * @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;
@@ -1836,11 +1869,12 @@ class PathEvent {
    * @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;
@@ -1854,7 +1888,7 @@ class PathEvent {
    * @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
@@ -1863,7 +1897,7 @@ class PathEvent {
    * @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
@@ -1872,7 +1906,7 @@ class PathEvent {
    * @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
@@ -1894,7 +1928,7 @@ class PathEvent {
    * @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
@@ -1903,7 +1937,7 @@ class PathEvent {
    * @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
@@ -1911,7 +1945,7 @@ class PathEvent {
    * @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
@@ -1919,7 +1953,7 @@ class PathEvent {
    * @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
@@ -1928,7 +1962,7 @@ class PathEvent {
    * @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
@@ -1936,16 +1970,19 @@ class PathEvent {
    * @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) {
@@ -1953,7 +1990,7 @@ class PathEventEmitter {
   }
   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);