@ztimson/utils 0.28.2 → 0.28.4

package/dist/index.mjs

@@ -424,6 +424,8 @@ function sortByProp(prop, reverse = false) {
   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;
@@ -2350,8 +2352,11 @@ function findTemplateVars(html) {
   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" }),
@@ -2361,65 +2366,144 @@ async function renderTemplate(template, data, fetch2) {
     },
     ...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 = {};