@ztimson/utils 0.27.14 → 0.27.16

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
      *
@@ -2308,6 +2293,68 @@ ${opts.message || this.desc}`;
       }).length == and.length;
     });
   }
+  class TemplateError extends BadRequestError {
+  }
+  async function renderTemplate(template, data, fetch2) {
+    let content = template, found;
+    const now = /* @__PURE__ */ new Date(), d = {
+      date: {
+        day: now.getDate(),
+        month: now.toLocaleString("default", { month: "long" }),
+        year: now.getFullYear(),
+        time: now.toLocaleTimeString(),
+        format: formatDate
+      },
+      ...data || {}
+    };
+    if (!fetch2) fetch2 = (file) => {
+      throw new TemplateError(`Unable to fetch template: ${file}`);
+    };
+    const evaluate = (code, data2, fatal = true) => {
+      try {
+        return Function("data", `Object.assign(this, data); return ${code};`)(data2);
+      } catch {
+        if (fatal) throw new TemplateError(`Failed to evaluate: ${code}`);
+        else return false;
+      }
+    };
+    while (!!(found = /\{\{\s*?\?\s*?(.+?)\s*?}}([\s\S]*?)(?:\{\{\s*?!\?\s*?}}([\s\S]*?))?\{\{\s*?\/\?\s*?}}/g.exec(content))) {
+      const nested = matchAll(found[0], /\{\{\s*?\?.+?}}/g).slice(-1)?.[0]?.index;
+      if (nested != 0)
+        found = /\{\{\s*?\?\s*?(.+?)\s*?}}([\s\S]*?)(?:\{\{\s*?!\?\s*?}}([\s\S]*?))?\{\{\s*?\/\?\s*?}}/g.exec(content.slice(found.index + nested));
+      content = content.replaceAll(found[0], (evaluate(found[1], d, false) ? found[2] : found[3]) || "");
+    }
+    while (!!(found = /\{\{\s*?<\s*?(.+?)\s*?}}/g.exec(content))) {
+      content = content.replaceAll(found[0], await renderTemplate(await fetch2(found[1].trim()), data, fetch2));
+    }
+    while (!!(found = /\{\{\s*?\*\s*?(.+?)\s+in\s+(.+?)\s*?}}([\s\S]*?)\{\{\s*?\/\*\s*?}}/g.exec(content))) {
+      const split = found[1].replaceAll(/[()\s]/g, "").split(",");
+      const element = split[0];
+      const index = split[1] || "index";
+      const array = dotNotation(data, found[2]);
+      if (!array || typeof array != "object")
+        throw new TemplateError(`Cannot iterate: ${found[2]}`);
+      let compiled = [];
+      for (let i = 0; i < array.length; i++) {
+        compiled.push(renderTemplate(found[3], {
+          ...d,
+          [element]: array[i],
+          [index]: i
+        }, fetch2));
+      }
+      content = content.replaceAll(found[0], compiled.join("\n"));
+    }
+    while (!!(found = /\{\{\s*([^<>\*\?!/}\s][^}]*?)\s*}}/g.exec(content))) {
+      content = content.replaceAll(found[0], evaluate(found[1].trim(), d) || "");
+    }
+    while (!!(found = /\{\{\s*?>\s*?(.+?):(.+?)\s*?}}([\s\S]*?)\{\{\s*?\/>\s*?}}/g.exec(content))) {
+      content = content.replace(found[0], await renderTemplate(await fetch2(found[1].trim), {
+        ...data,
+        [found[2].trim()]: found[3]
+      }, fetch2));
+    }
+    return content;
+  }
   var dist = {};
   var persist = {};
   var hasRequiredPersist;
@@ -2531,6 +2578,7 @@ ${opts.message || this.desc}`;
   exports2.SYMBOL_LIST = SYMBOL_LIST;
   exports2.ServiceUnavailableError = ServiceUnavailableError;
   exports2.Table = Table;
+  exports2.TemplateError = TemplateError;
   exports2.TypedEmitter = TypedEmitter;
   exports2.UnauthorizedError = UnauthorizedError;
   exports2.addUnique = addUnique;
@@ -2592,6 +2640,7 @@ ${opts.message || this.desc}`;
   exports2.randomHex = randomHex;
   exports2.randomString = randomString;
   exports2.randomStringBuilder = randomStringBuilder;
+  exports2.renderTemplate = renderTemplate;
   exports2.reservedIp = reservedIp;
   exports2.search = search;
   exports2.sleep = sleep;