@ztimson/utils 0.28.2 → 0.28.4

package/dist/index.cjs

@@ -428,6 +428,8 @@ ${opts.message || this.desc}`;
     return function(a, b) {
       const aVal = dotNotation(a, prop);
       const bVal = dotNotation(b, prop);
+      if (aVal === void 0) return 1;
+      if (bVal === void 0) return -1;
       if (typeof aVal == "number" && typeof bVal == "number")
         return (reverse ? -1 : 1) * (aVal - bVal);
       if (aVal > bVal) return reverse ? -1 : 1;
@@ -2354,8 +2356,11 @@ ${opts.message || this.desc}`;
     return result;
   }
   async function renderTemplate(template, data, fetch2) {
-    let content = template, found;
-    const now = /* @__PURE__ */ new Date(), d = {
+    if (!fetch2) fetch2 = (file) => {
+      throw new TemplateError(`Unable to fetch template: ${file}`);
+    };
+    const now = /* @__PURE__ */ new Date();
+    const d = {
       date: {
         day: now.getDate(),
         month: now.toLocaleString("default", { month: "long" }),
@@ -2365,65 +2370,144 @@ ${opts.message || this.desc}`;
       },
       ...data || {}
     };
-    if (!fetch2) fetch2 = (file) => {
-      throw new TemplateError(`Unable to fetch template: ${file}`);
-    };
     const evaluate = (code, data2, fatal = true) => {
       try {
         return Function("data", `with(data) { return ${code}; }`)(data2);
-      } catch {
-        if (fatal) throw new TemplateError(`Failed to evaluate: ${code}`);
-        else return false;
+      } catch (err) {
+        if (fatal) throw new TemplateError(`Failed to evaluate: ${code}
+${err.message || err.toString()}`);
+        return false;
       }
     };
-    while (!!(found = /\{\{\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*?}}/g.exec(content.slice(found.index + nested));
-      const parts = found[2].split(/\{\{\s*?!\?\s*?/);
-      let result = evaluate(found[1], d, false) ? parts[0] : "";
-      if (!result) {
-        for (let i = 1; i < parts.length; i++) {
-          const [cond, body] = parts[i].split(/}}/);
-          if (!cond.trim()) {
-            result = body || "";
-            break;
-          }
-          if (evaluate(cond, d, false)) {
-            result = body || "";
-            break;
+    async function process(content, ctx = d) {
+      let result = content;
+      const extendsMatch = result.match(/\{\{\s*>\s*(.+?):(.+?)\s*}}([\s\S]*?)\{\{\s*\/>\s*}}/);
+      if (extendsMatch) {
+        const parentTemplate = await fetch2(extendsMatch[1].trim());
+        if (!parentTemplate) throw new TemplateError(`Unknown extended template: ${extendsMatch[1].trim()}`);
+        const slotName = extendsMatch[2].trim();
+        const slotContent = await process(extendsMatch[3], ctx);
+        return process(parentTemplate, { ...ctx, [slotName]: slotContent });
+      }
+      let changed = true;
+      while (changed) {
+        changed = false;
+        const before = result;
+        const importMatch = result.match(/\{\{\s*<\s*(.+?)\s*}}/);
+        if (importMatch) {
+          const t = await fetch2(importMatch[1].trim());
+          if (!t) throw new TemplateError(`Unknown imported template: ${importMatch[1].trim()}`);
+          const rendered = await process(t, ctx);
+          result = result.replace(importMatch[0], rendered);
+          changed = true;
+          continue;
+        }
+        const forMatch = findInnermostFor(result);
+        if (forMatch) {
+          const { full, vars, array, body, start } = forMatch;
+          const [element, index = "index"] = vars.split(",").map((v) => v.trim());
+          const arr = dotNotation(ctx, array);
+          if (!arr || typeof arr != "object") throw new TemplateError(`Cannot iterate: ${array}`);
+          let output = [];
+          for (let i = 0; i < arr.length; i++)
+            output.push(await process(body, { ...ctx, [element]: arr[i], [index]: i }));
+          result = result.slice(0, start) + output.join("\n") + result.slice(start + full.length);
+          changed = true;
+          continue;
+        }
+        const ifMatch = findInnermostIf(result);
+        if (ifMatch) {
+          const { full, condition, body, start } = ifMatch;
+          const branches = parseIfBranches(body);
+          let output = "";
+          if (evaluate(condition, ctx, false)) {
+            output = branches.if;
+          } else {
+            for (const branch of branches.elseIf) {
+              if (evaluate(branch.condition, ctx, false)) {
+                output = branch.body;
+                break;
+              }
+            }
+            if (!output && branches.else) output = branches.else;
           }
+          result = result.slice(0, start) + output + result.slice(start + full.length);
+          changed = true;
+          continue;
+        }
+        if (before === result) changed = false;
+      }
+      return processVariables(result, ctx);
+    }
+    function processVariables(content, data2) {
+      return content.replace(/\{\{\s*([^<>\*\?!/}\s][^{}]*?)\s*}}/g, (match, code) => {
+        return evaluate(code.trim(), data2) ?? "";
+      });
+    }
+    function findInnermostIf(content) {
+      const regex = /\{\{\s*\?\s*(.+?)\s*}}/g;
+      let match, lastMatch = null;
+      while ((match = regex.exec(content)) !== null) {
+        const start = match.index;
+        const condition = match[1];
+        const bodyStart = match.index + match[0].length;
+        const end = findMatchingClose(content, bodyStart, /\{\{\s*\?\s*/, /\{\{\s*\/\?\s*}}/);
+        if (end === -1) throw new TemplateError(`Unmatched if-statement at position ${start}`);
+        const closeTag = content.slice(end).match(/\{\{\s*\/\?\s*}}/);
+        const full = content.slice(start, end + closeTag[0].length);
+        const body = content.slice(bodyStart, end);
+        lastMatch = { full, condition, body, start };
+      }
+      return lastMatch;
+    }
+    function findInnermostFor(content) {
+      const regex = /\{\{\s*\*\s*(.+?)\s+in\s+(.+?)\s*}}/g;
+      let match, lastMatch = null;
+      while ((match = regex.exec(content)) !== null) {
+        const start = match.index;
+        const vars = match[1].replaceAll(/[()\s]/g, "");
+        const array = match[2];
+        const bodyStart = match.index + match[0].length;
+        const end = findMatchingClose(content, bodyStart, /\{\{\s*\*\s*/, /\{\{\s*\/\*\s*}}/);
+        if (end === -1) throw new TemplateError(`Unmatched for-loop at position ${start}`);
+        const closeTag = content.slice(end).match(/\{\{\s*\/\*\s*}}/);
+        const full = content.slice(start, end + closeTag[0].length);
+        const body = content.slice(bodyStart, end);
+        lastMatch = { full, vars, array, body, start };
+      }
+      return lastMatch;
+    }
+    function findMatchingClose(content, startIndex, openTag, closeTag) {
+      let depth = 1, pos = startIndex;
+      while (depth > 0 && pos < content.length) {
+        const remaining = content.slice(pos);
+        const nextOpen = remaining.search(openTag);
+        const nextClose = remaining.search(closeTag);
+        if (nextClose === -1) return -1;
+        if (nextOpen !== -1 && nextOpen < nextClose) {
+          depth++;
+          pos += nextOpen + 1;
+        } else {
+          depth--;
+          if (depth === 0) return pos + nextClose;
+          pos += nextClose + 1;
         }
       }
-      content = content.replace(found[0], result);
-    }
-    while (!!(found = /\{\{\s*?<\s*?(.+?)\s*?}}/g.exec(content))) {
-      const t = await fetch2(found[1].trim());
-      if (!t) throw new TemplateError(`Unknown imported template: ${found[1].trim()}`);
-      content = content.replace(found[0], await renderTemplate(t, d, 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(d, 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(await renderTemplate(found[3], { ...d, [element]: array[i], [index]: i }, fetch2));
-      content = content.replace(found[0], compiled.join("\n"));
-    }
-    while (!!(found = /\{\{\s*([^<>\*\?!/}\s][^}]*?)\s*}}/g.exec(content))) {
-      content = content.replace(found[0], evaluate(found[1].trim(), d) ?? "");
-    }
-    while (!!(found = /\{\{\s*?>\s*?(.+?):(.+?)\s*?}}([\s\S]*?)\{\{\s*?\/>\s*?}}/g.exec(content))) {
-      const t = await fetch2(found[1].trim());
-      if (!t) throw new TemplateError(`Unknown extended templated: ${found[1].trim()}`);
-      content = content.replace(found[0], await renderTemplate(t, {
-        ...d,
-        [found[2].trim()]: found[3]
-      }, fetch2));
-    }
-    return content;
+      return -1;
+    }
+    function parseIfBranches(body) {
+      const parts = body.split(/\{\{\s*!\?\s*/);
+      const result = { if: parts[0], elseIf: [], else: "" };
+      for (let i = 1; i < parts.length; i++) {
+        const closeBrace = parts[i].indexOf("}}");
+        const condition = parts[i].slice(0, closeBrace).trim();
+        const branchBody = parts[i].slice(closeBrace + 2);
+        if (!condition) result.else = branchBody;
+        else result.elseIf.push({ condition, body: branchBody });
+      }
+      return result;
+    }
+    return process(template);
   }
   var dist = {};
   var persist = {};