miki-template 2.2.2 → 2.3.0

package/src/context.js

@@ -12,6 +12,18 @@ class Context {
     this.partialDefs = new Map(); // Store partial definitions
   }
 
+  get _local() {
+    return this.scopes[0] || {};
+  }
+
+  set _local(value) {
+    if (this.scopes.length === 0) {
+      this.scopes.unshift(value);
+    } else {
+      this.scopes[0] = value;
+    }
+  }
+
   /**
    * Reset cycle state and blocks for a fresh render.
    * Called at the start of each render pass.
@@ -49,14 +61,20 @@ class Context {
       return '';
     }
 
-    const parts = path.split('.');
-    const baseName = parts[0];
+    // Fast path for non-dotted single variable lookups
+    const isString = typeof path === 'string';
+    const hasDot = isString && path.includes('.');
+
+    const baseName = hasDot ? path.split('.')[0] : path;
 
     let current = undefined;
     let found = false;
 
     // Search scopes from top (most local) to bottom (most global)
-    for (const scope of this.scopes) {
+    const scopes = this.scopes;
+    const len = scopes.length;
+    for (let i = 0; i < len; i++) {
+      const scope = scopes[i];
       if (scope && typeof scope === 'object' && baseName in scope) {
         current = scope[baseName];
         found = true;
@@ -65,43 +83,37 @@ class Context {
     }
 
     if (!found) {
-      // Variable truly missing — return undefined so templates can
-      // distinguish "missing" from "explicitly null". The variable node
-      // and filters handle undefined gracefully.
       return undefined;
     }
 
-    // Traverse the rest of the dotted segments
-    for (let i = 1; i < parts.length; i++) {
-      if (current === undefined || current === null) {
-        return current === null ? null : undefined;
-      }
-
-      const parent = current;
-      const part = parts[i];
-
-      // Resolve segment on the current value
-      if (typeof current === 'object' && part in current) {
-        current = current[part];
-      } else if (Array.isArray(current) && !isNaN(part)) {
-        // Handle array index resolution, e.g. items.0
-        current = current[parseInt(part, 10)];
-      } else {
-        return undefined;
-      }
-
-      // If the property value is a function, evaluate it (Django style)
-      if (typeof current === 'function') {
-        current = current.call(parent);
+    if (hasDot) {
+      const parts = path.split('.');
+      for (let i = 1; i < parts.length; i++) {
+        if (current === undefined || current === null) {
+          return current === null ? null : undefined;
+        }
+
+        const parent = current;
+        const part = parts[i];
+
+        if (typeof current === 'object' && part in current) {
+          current = current[part];
+        } else if (Array.isArray(current) && !isNaN(part)) {
+          current = current[parseInt(part, 10)];
+        } else {
+          return undefined;
+        }
+
+        if (typeof current === 'function') {
+          current = current.call(parent);
+        }
       }
     }
 
-    // If the final resolved value is a function, call it with no arguments
     if (typeof current === 'function') {
       current = current.call(null);
     }
 
-    // Preserve null/undefined so filters like default_if_none can detect them.
     return current;
   }
 

package/src/filters.js

@@ -971,5 +971,21 @@ registerFilter('uuid', () => {
   });
 });
 
+registerFilter('repeat', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const count = parseInt(arg, 10);
+  if (Number.isNaN(count) || count <= 0) return '';
+  return str.repeat(count);
+});
+
+registerFilter('range', (val, arg) => {
+  const end = parseInt(val, 10);
+  const start = arg !== undefined && arg !== null ? parseInt(arg, 10) : 0;
+  const step = 1;
+  const out = [];
+  for (let i = start; i < end; i += step) out.push(i);
+  return out;
+});
+
 module.exports = { registerFilter, getFilter };
 

package/src/index.js

@@ -219,12 +219,15 @@ function readParentSource(parentName, viewsDirs) {
 
 async function renderASTAsync(nodes, context) {
   context.parentTemplate = null;
-  const parts = [];
-  for (const node of nodes) {
-    const result = node.render(context);
-    parts.push(result instanceof Promise ? await result : result);
+  let output = '';
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    const result = nodes[i].render(context);
+    if (result instanceof Promise) {
+      output += await result;
+    } else {
+      output += result;
+    }
   }
-  let output = parts.join('');
 
   if (context.parentTemplate) {
     const parentName = context.parentTemplate;
@@ -279,13 +282,14 @@ async function renderASTAsync(nodes, context) {
  */
 function renderAST(nodes, context) {
   context.parentTemplate = null;
-  const output = nodes.map(node => {
-    const result = node.render(context);
+  let output = '';
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    const result = nodes[i].render(context);
     if (result instanceof Promise) {
       throw new Error('Async node encountered during sync render. Use asyncRender() instead.');
     }
-    return result;
-  }).join('');
+    output += result;
+  }
 
   if (context.parentTemplate) {
     const parentName = context.parentTemplate;
@@ -354,78 +358,79 @@ function compile(templateStr, options = {}) {
     }
     collectPartials(nodes);
 
+    const { renderBody } = require('./utils');
+    const { generateCode, canCodegen } = require('./codegen');
+
+    const useCodegen = true;
+    let compiledRender = null;
+    if (useCodegen && canCodegen(nodes)) {
+      compiledRender = generateCode(nodes);
+    }
+
+    function makeContext(contextObj, callOpts) {
+      const mergedOpts = callOpts ? { ...opts, ...callOpts } : opts;
+      const processedContextObj = applyContextProcessors({ ...contextObj });
+      const context = new Context(processedContextObj, mergedOpts);
+      context.reset();
+      if (parser.blocks) {
+        for (const [name, blockList] of Object.entries(parser.blocks)) {
+          context.blocks[name] = [...blockList];
+        }
+      }
+      for (const [name, partial] of Object.entries(partialDefs)) {
+        context.registerPartial(name, partial);
+      }
+      return context;
+    }
+
     return {
+      _usesCodegen: !!compiledRender,
       render: (contextObj = {}) => {
-        const processedContextObj = applyContextProcessors({ ...contextObj });
-        const context = new Context(processedContextObj, opts);
-        context.reset();
-        if (parser.blocks) {
-          for (const [name, blockList] of Object.entries(parser.blocks)) {
-            context.blocks[name] = [...blockList];
+        const context = makeContext(contextObj);
+        if (compiledRender) {
+          const res = compiledRender(context);
+          if (context.parentTemplate) {
+            return renderAST(nodes, context);
           }
-        }
-        // Register partial definitions from compile-time
-        for (const [name, partial] of Object.entries(partialDefs)) {
-          context.registerPartial(name, partial);
+          return res;
         }
         return renderAST(nodes, context);
       },
       renderWith: (contextObj = {}, callOptions = {}) => {
-        const processedContextObj = applyContextProcessors({ ...contextObj });
-        const mergedOpts = { ...opts, ...callOptions };
-        const context = new Context(processedContextObj, mergedOpts);
-        context.reset();
-        if (parser.blocks) {
-          for (const [name, blockList] of Object.entries(parser.blocks)) {
-            context.blocks[name] = [...blockList];
+        const context = makeContext(contextObj, callOptions);
+        if (compiledRender) {
+          const res = compiledRender(context);
+          if (context.parentTemplate) {
+            return renderAST(nodes, context);
           }
-        }
-        for (const [name, partial] of Object.entries(partialDefs)) {
-          context.registerPartial(name, partial);
+          return res;
         }
         return renderAST(nodes, context);
       },
       asyncRender: async (contextObj = {}) => {
-        const processedContextObj = applyContextProcessors({ ...contextObj });
-        const context = new Context(processedContextObj, opts);
-        context.blocks = {};
-        if (parser.blocks) {
-          for (const [name, blockList] of Object.entries(parser.blocks)) {
-            context.blocks[name] = [...blockList];
+        const context = makeContext(contextObj);
+        if (compiledRender) {
+          const res = compiledRender(context);
+          if (context.parentTemplate || res instanceof Promise || (typeof res === 'string' && res.includes('[object Promise]'))) {
+            return await renderASTAsync(nodes, context);
           }
-        }
-        for (const [name, partial] of Object.entries(partialDefs)) {
-          context.registerPartial(name, partial);
+          return res;
         }
         return await renderASTAsync(nodes, context);
       },
       asyncRenderWith: async (contextObj = {}, callOptions = {}) => {
-        const processedContextObj = applyContextProcessors({ ...contextObj });
-        const mergedOpts = { ...opts, ...callOptions };
-        const context = new Context(processedContextObj, mergedOpts);
-        context.blocks = {};
-        if (parser.blocks) {
-          for (const [name, blockList] of Object.entries(parser.blocks)) {
-            context.blocks[name] = [...blockList];
+        const context = makeContext(contextObj, callOptions);
+        if (compiledRender) {
+          const res = compiledRender(context);
+          if (context.parentTemplate || res instanceof Promise || (typeof res === 'string' && res.includes('[object Promise]'))) {
+            return await renderASTAsync(nodes, context);
           }
-        }
-        for (const [name, partial] of Object.entries(partialDefs)) {
-          context.registerPartial(name, partial);
+          return res;
         }
         return await renderASTAsync(nodes, context);
       },
       renderBlock: (blockName, contextObj = {}) => {
-        const processedContextObj = applyContextProcessors({ ...contextObj });
-        const context = new Context(processedContextObj, opts);
-        context.blocks = {};
-        if (parser.blocks) {
-          for (const [name, blockList] of Object.entries(parser.blocks)) {
-            context.blocks[name] = [...blockList];
-          }
-        }
-        for (const [name, partial] of Object.entries(partialDefs)) {
-          context.registerPartial(name, partial);
-        }
+        const context = makeContext(contextObj);
         renderAST(nodes, context);
         const blockStack = context.blocks[blockName];
         if (!blockStack || blockStack.length === 0) {
@@ -442,7 +447,7 @@ function compile(templateStr, options = {}) {
         }
         context.push({ block: { super: superVal } });
         context.blockRenderIndices[blockName] = 0;
-        const result = blockStack[0].body.map(n => n.render(context)).join('');
+        const result = renderBody(blockStack[0].body, context);
         context.pop();
         context.blockRenderIndices[blockName] = -1;
         return result;
@@ -457,7 +462,7 @@ function compile(templateStr, options = {}) {
         if (!partial) {
           throw new Error(`Partial '${partialName}' not found`);
         }
-        return partial.body.map(n => n.render(context)).join('');
+        return renderBody(partial.body, context);
       }
     };
   });

package/src/tags/control.js

@@ -2,6 +2,7 @@
  * Control flow template tags: if, for, with, cycle, comment, with, firstof.
  */
 const { parseVariableExpression } = require('../parser');
+const { getFilter } = require('../filters');
 
 /**
  * Helper to parse a string into an array of tokens.
@@ -206,27 +207,28 @@ class ForNode {
     this.filters = filters;
     this.body = body;
     this.emptyBody = emptyBody;
+    this._filterFns = filters.map(f => {
+      const fn = getFilter(f.name);
+      return { fn, arg: f.arg };
+    });
   }
 
   render(context) {
     let rawItems = context.get(this.iterablePath);
 
-    // Apply any filters on the iterable path (e.g. items|regroup:"category")
-    const { getFilter } = require('../filters');
-    for (const filterInfo of this.filters) {
-      const filterFn = getFilter(filterInfo.name);
-      if (!filterFn) {
-        throw new Error(`Unknown filter: '${filterInfo.name}'`);
+    for (const { fn, arg } of this._filterFns) {
+      if (!fn) {
+        throw new Error(`Unknown filter: '${arg.name}'`);
       }
       let argVal = undefined;
-      if (filterInfo.arg) {
-        if (filterInfo.arg.type === 'literal') {
-          argVal = filterInfo.arg.value;
-        } else if (filterInfo.arg.type === 'variable') {
-          argVal = context.get(filterInfo.arg.value);
+      if (arg) {
+        if (arg.type === 'literal') {
+          argVal = arg.value;
+        } else if (arg.type === 'variable') {
+          argVal = context.get(arg.value);
         }
       }
-      rawItems = filterFn(rawItems, argVal);
+      rawItems = fn(rawItems, argVal);
     }
 
     let items = [];
@@ -706,6 +708,7 @@ module.exports = {
   PartialDefNode,
   PartialNode,
   evaluateCondition,
+  tokenizeExpr,
   parsers: {
     if: parseIf,
     for: parseFor,

package/src/utils.js

@@ -0,0 +1,60 @@
+/**
+ * Fast string concatenation for an array of AST nodes.
+ *
+ * Replaces the common pattern
+ *   body.map(n => n.render(context)).join('')
+ * with a tight loop that calls .render() and concatenates directly.
+ * V8 optimizes `let s = ''; s += x` well (cons strings), whereas
+ * `.map().join('')` allocates an intermediate array.
+ */
+function renderBody(body, context) {
+  let out = '';
+  if (!body) return out;
+  for (let i = 0, len = body.length; i < len; i++) {
+    const r = body[i].render(context);
+    if (r instanceof Promise) {
+      out += '';
+    } else {
+      out += r;
+    }
+  }
+  return out;
+}
+
+/**
+ * Async version of renderBody — awaits Promises from any node.
+ */
+async function renderBodyAsync(body, context) {
+  let out = '';
+  if (!body) return out;
+  for (let i = 0, len = body.length; i < len; i++) {
+    const r = body[i].render(context);
+    if (r instanceof Promise) out += await r;
+    else out += r;
+  }
+  return out;
+}
+
+/**
+ * Render body, returning a Promise or string based on what nodes
+ * produce. Used by HelperNode and the render* entry points.
+ */
+function renderBodyMaybeAsync(body, context) {
+  let out = '';
+  let pending = null;
+  for (let i = 0, len = body.length; i < len; i++) {
+    const r = body[i].render(context);
+    if (r instanceof Promise) {
+      if (!pending) pending = [];
+      pending.push(r.then(v => { out += v; }));
+    } else {
+      out += r;
+    }
+  }
+  if (pending) {
+    return Promise.all(pending).then(() => out);
+  }
+  return out;
+}
+
+module.exports = { renderBody, renderBodyAsync, renderBodyMaybeAsync };

package/tests/filters.test.js

@@ -251,4 +251,13 @@ test('Filters - credit_card, ssn, ip_address, uuid', () => {
 
   const uuid = getFilter('uuid');
   assert.ok(uuid().match(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/));
+
+  test('Filters - repeat and range', () => {
+    const repeat = getFilter('repeat');
+    assert.strictEqual(repeat('a', 3), 'aaa');
+    assert.strictEqual(repeat('', 5), '');
+    const range = getFilter('range');
+    assert.deepEqual(range('5'), [0,1,2,3,4]);
+    assert.deepEqual(range('5', '2'), [2,3,4]);
+  });
 });

package/.github/workflows/npm-publish-github-packages.yml

@@ -1,36 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm test
-
-  publish-gpr:
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://npm.pkg.github.com/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/docs/javascripts/extra.js

@@ -1,174 +0,0 @@
-document$.subscribe(function () {
-  console.log("miki-template docs initialized");
-
-  const navbar = document.querySelector(".md-header");
-  if (navbar) {
-    let lastScroll = 0;
-    const scrollThreshold = 50;
-
-    window.addEventListener("scroll", function () {
-      const currentScroll = window.pageYOffset;
-
-      if (currentScroll <= 0) {
-        navbar.style.boxShadow = "0 2px 8px var(--md-shadow-color)";
-        return;
-      }
-
-      if (currentScroll > lastScroll && currentScroll > scrollThreshold) {
-        navbar.style.transform = "translateY(-100%)";
-        navbar.style.transition = "transform 0.3s ease";
-      } else {
-        navbar.style.transform = "translateY(0)";
-        navbar.style.transition = "transform 0.3s ease";
-      }
-
-      lastScroll = currentScroll;
-    });
-  }
-
-  document.querySelectorAll(".md-clipboard").forEach(function (button) {
-    button.addEventListener("click", async function () {
-      const code = this.closest(".highlight").querySelector("code").innerText;
-
-      try {
-        await navigator.clipboard.writeText(code);
-        const originalHTML = this.innerHTML;
-        this.innerHTML = '<span class="md-icon">&#10003;</span> Copied!';
-        this.style.color = "var(--md-accent-fg-color)";
-        this.style.opacity = "1";
-
-        setTimeout(function () {
-          button.innerHTML = originalHTML;
-          button.style.color = "";
-          button.style.opacity = "";
-        }, 2000);
-      } catch (err) {
-        console.error("Failed to copy: ", err);
-      }
-    });
-  });
-
-  document.querySelectorAll(".md-typeset a[href^='#']").forEach(function (anchor) {
-    anchor.addEventListener("click", function (e) {
-      const targetId = this.getAttribute("href");
-      if (targetId === "#") return;
-
-      const target = document.querySelector(targetId);
-      if (target) {
-        e.preventDefault();
-        const headerOffset = 80;
-        const elementPosition = target.getBoundingClientRect().top;
-        const offsetPosition = elementPosition + window.pageYOffset - headerOffset;
-
-        window.scrollTo({
-          top: offsetPosition,
-          behavior: "smooth",
-        });
-
-        history.replaceState(null, null, targetId);
-      }
-    });
-  });
-
-  document.querySelectorAll(".md-typeset .task-list-item input[type='checkbox']").forEach(function (checkbox) {
-    checkbox.addEventListener("change", function () {
-      const label = this.closest(".task-list-item");
-      if (this.checked) {
-        label.style.opacity = "0.6";
-        label.style.textDecoration = "line-through";
-      } else {
-        label.style.opacity = "1";
-        label.style.textDecoration = "none";
-      }
-    });
-  });
-
-  document.querySelectorAll(".md-tabs__link").forEach(function (tab) {
-    tab.addEventListener("click", function () {
-      document.querySelectorAll(".md-tabs__link").forEach(function (t) {
-        t.style.transform = "scale(1)";
-      });
-      this.style.transform = "scale(1.05)";
-      setTimeout(function () {
-        tab.style.transform = "scale(1)";
-      }, 200);
-    });
-  });
-
-  document.querySelectorAll(".md-typeset .tabbed-set > label").forEach(function (tabLabel) {
-    tabLabel.addEventListener("click", function () {
-      this.style.transform = "scale(0.98)";
-      setTimeout(function () {
-        tabLabel.style.transform = "scale(1)";
-      }, 100);
-    });
-  });
-
-  const searchInput = document.querySelector(".md-search__input");
-  if (searchInput) {
-    searchInput.addEventListener("focus", function () {
-      this.parentElement.style.boxShadow = "0 0 0 3px var(--md-accent-fg-color), 0 4px 12px var(--md-shadow-color)";
-      this.parentElement.style.transition = "box-shadow 0.2s ease";
-    });
-
-    searchInput.addEventListener("blur", function () {
-      this.parentElement.style.boxShadow = "";
-    });
-  }
-
-  document.querySelectorAll(".md-typeset .admonition").forEach(function (admonition) {
-    admonition.addEventListener("mouseenter", function () {
-      this.style.transform = "translateY(-2px)";
-      this.style.transition = "transform 0.2s ease";
-    });
-
-    admonition.addEventListener("mouseleave", function () {
-      this.style.transform = "translateY(0)";
-    });
-  });
-
-  document.querySelectorAll(".md-typeset .md-button").forEach(function (button) {
-    button.addEventListener("mouseenter", function () {
-      this.style.transform = "translateY(-2px)";
-    });
-
-    button.addEventListener("mouseleave", function () {
-      this.style.transform = "translateY(0)";
-    });
-  });
-
-  document.querySelectorAll(".md-content__inner table:not([class]) tbody tr").forEach(function (row) {
-    row.addEventListener("mouseenter", function () {
-      this.style.transition = "background-color 0.2s ease";
-    });
-  });
-
-  const observerOptions = {
-    root: null,
-    rootMargin: "0px",
-    threshold: 0.1,
-  };
-
-  const observer = new IntersectionObserver(function (entries) {
-    entries.forEach(function (entry) {
-      if (entry.isIntersecting) {
-        entry.target.style.opacity = "1";
-        entry.target.style.transform = "translateY(0)";
-      }
-    });
-  }, observerOptions);
-
-  document.querySelectorAll(".md-typeset h2, .md-typeset h3, .md-typeset .admonition").forEach(function (el) {
-    el.style.opacity = "0";
-    el.style.transform = "translateY(10px)";
-    el.style.transition = "opacity 0.5s ease, transform 0.5s ease";
-    observer.observe(el);
-  });
-
-  setTimeout(function () {
-    document.querySelectorAll(".md-typeset h2, .md-typeset h3, .md-typeset .admonition").forEach(function (el) {
-      el.style.opacity = "1";
-      el.style.transform = "translateY(0)";
-    });
-  }, 100);
-});