@ztimson/utils 0.27.14 → 0.27.15

package/dist/index.cjs

@@ -1958,7 +1958,7 @@ ${opts.message || this.desc}`;
         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 = "";
@@ -1979,27 +1979,19 @@ ${opts.message || this.desc}`;
       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
@@ -2014,14 +2006,9 @@ ${opts.message || this.desc}`;
       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;
@@ -2029,18 +2016,36 @@ ${opts.message || this.desc}`;
           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
@@ -2061,9 +2066,7 @@ ${opts.message || this.desc}`;
           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]);
           }
         }
@@ -2082,24 +2085,6 @@ ${opts.message || this.desc}`;
       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
      *