@ztimson/utils 0.27.14 → 0.27.15

package/dist/index.mjs

@@ -1954,7 +1954,7 @@ class PathEvent {
       Object.assign(this, PathEvent.pathEventCache.get(e));
       return;
     }
-    let [p, method] = e.replaceAll(/\/{2,}/g, "/").split(":");
+    let [p, method] = e.replaceAll(/(^|\/)\*+\/?$/g, "").split(":");
     if (!method) method = "*";
     if (p === "" || p === void 0 || p === "*") {
       this.module = "";
@@ -1975,27 +1975,19 @@ class PathEvent {
     this.methods = new ASet(method.split(""));
     PathEvent.pathEventCache.set(e, this);
   }
-  /** Clear the cache of all PathEvents */
-  static clearCache() {
-    PathEvent.pathEventCache.clear();
-  }
-  /** Clear the permission cache */
-  static clearPermissionCache() {
-    PathEvent.permissionCache.clear();
-  }
   /**
-   * Score a path for specificity ranking (lower = more specific = higher priority)
+   * Check if a filter pattern matches a target path
    * @private
    */
-  static scoreSpecificity(path) {
-    if (path === "**" || path === "") return Number.MAX_SAFE_INTEGER;
-    const segments = path.split("/").filter((p) => !!p);
-    let score = -segments.length;
-    segments.forEach((seg) => {
-      if (seg === "**") score += 0.5;
-      else if (seg === "*") score += 0.25;
-    });
-    return score;
+  static matches(pattern, target) {
+    const methodsMatch = pattern.all || target.all || pattern.methods.intersection(target.methods).length > 0;
+    if (!methodsMatch) return false;
+    if (!pattern.hasGlob && !target.hasGlob) {
+      const last = pattern.fullPath[target.fullPath.length];
+      return pattern.fullPath.startsWith(target.fullPath) && (last == null || last == "/");
+    }
+    if (pattern.hasGlob) return this.pathMatchesGlob(target.fullPath, pattern.fullPath);
+    return this.pathMatchesGlob(pattern.fullPath, target.fullPath);
   }
   /**
    * Check if a path matches a glob pattern
@@ -2010,14 +2002,9 @@ class PathEvent {
     while (patternIdx < patternParts.length && pathIdx < pathParts.length) {
       const patternPart = patternParts[patternIdx];
       if (patternPart === "**") {
-        if (patternIdx === patternParts.length - 1) {
-          return true;
-        }
-        patternParts[patternIdx + 1];
+        if (patternIdx === patternParts.length - 1) return true;
         while (pathIdx < pathParts.length) {
-          if (PathEvent.pathMatchesGlob(pathParts.slice(pathIdx).join("/"), patternParts.slice(patternIdx + 1).join("/"))) {
-            return true;
-          }
+          if (PathEvent.pathMatchesGlob(pathParts.slice(pathIdx).join("/"), patternParts.slice(patternIdx + 1).join("/"))) return true;
           pathIdx++;
         }
         return false;
@@ -2025,18 +2012,36 @@ class PathEvent {
         pathIdx++;
         patternIdx++;
       } else {
-        if (patternPart !== pathParts[pathIdx]) {
-          return false;
-        }
+        if (patternPart !== pathParts[pathIdx]) return false;
         pathIdx++;
         patternIdx++;
       }
     }
-    if (patternIdx < patternParts.length) {
-      return patternParts.slice(patternIdx).every((p) => p === "**");
-    }
+    if (patternIdx < patternParts.length) return patternParts.slice(patternIdx).every((p) => p === "**");
     return pathIdx === pathParts.length;
   }
+  /**
+   * Score a path for specificity ranking (lower = more specific = higher priority)
+   * @private
+   */
+  static scoreSpecificity(path) {
+    if (path === "**" || path === "") return Number.MAX_SAFE_INTEGER;
+    const segments = path.split("/").filter((p) => !!p);
+    let score = -segments.length;
+    segments.forEach((seg) => {
+      if (seg === "**") score += 0.5;
+      else if (seg === "*") score += 0.25;
+    });
+    return score;
+  }
+  /** Clear the cache of all PathEvents */
+  static clearCache() {
+    PathEvent.pathEventCache.clear();
+  }
+  /** Clear the permission cache */
+  static clearPermissionCache() {
+    PathEvent.permissionCache.clear();
+  }
   /**
    * Combine multiple events into one parsed object. Longest path takes precedent, but all subsequent methods are
    * combined until a "none" is reached
@@ -2057,9 +2062,7 @@ class PathEvent {
         result = p;
       } else {
         if (result.fullPath.startsWith(p.fullPath)) {
-          if (p.none) {
-            break;
-          }
+          if (p.none) break;
           result.methods = new ASet([...result.methods, ...p.methods]);
         }
       }
@@ -2078,24 +2081,6 @@ class PathEvent {
     const parsedFilter = makeArray(filter).map((pe) => pe instanceof PathEvent ? pe : new PathEvent(pe));
     return parsedTarget.filter((t) => !!parsedFilter.find((r) => PathEvent.matches(r, t)));
   }
-  /**
-   * Check if a filter pattern matches a target path
-   * @private
-   */
-  static matches(pattern, target) {
-    if (pattern.fullPath === "" || target.fullPath === "") return false;
-    if (pattern.fullPath === "**") return pattern.methods.has("*") || pattern.methods.intersection(target.methods).length > 0;
-    if (target.fullPath === "**") return pattern.methods.has("*") || target.methods.has("*") || pattern.methods.intersection(target.methods).length > 0;
-    const methodsMatch = pattern.all || target.all || pattern.methods.intersection(target.methods).length > 0;
-    if (!methodsMatch) return false;
-    if (!pattern.hasGlob && !target.hasGlob) {
-      return pattern.fullPath === target.fullPath;
-    }
-    if (pattern.hasGlob) {
-      return this.pathMatchesGlob(target.fullPath, pattern.fullPath);
-    }
-    return this.pathMatchesGlob(pattern.fullPath, target.fullPath);
-  }
   /**
    * Squash 2 sets of paths & return true if any overlap is found
    *