miki-template 2.3.2 → 2.3.4

package/src/tags/control.js

@@ -1,7 +1,7 @@
 /**
  * Control flow template tags: if, for, with, cycle, comment, with, firstof.
  */
-const { parseVariableExpression } = require('../parser');
+const { parseVariableExpression, evaluateExpression } = require('../parser');
 const { getFilter } = require('../filters');
 
 /**
@@ -81,23 +81,6 @@ function tokenizeExpr(exprStr) {
   return tokens;
 }
 
-/**
- * Helper to resolve a token to its runtime value.
- */
-function resolveValue(token, context) {
-  if (!token) return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (!isNaN(token) && token !== '') {
-    return Number(token);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  return context.get(token);
-}
-
 /**
  * Shunting-yard style expression evaluator supporting:
  * == != < <= > >= in not in and or not
@@ -161,7 +144,7 @@ function evaluateCondition(exprStr, context) {
       continue;
     }
 
-    vals.push(resolveValue(t, context));
+    vals.push(evaluateExpression(t, context));
   }
 
   while (ops.length > 0) {
@@ -201,12 +184,14 @@ class IfNode {
 }
 
 class ForNode {
-  constructor(loopVars, iterablePath, body, emptyBody, filters = []) {
+  constructor(loopVars, iterablePath, body, emptyBody, filters = [], isLiteral = false, literalValue = null) {
     this.loopVars = loopVars;
     this.iterablePath = iterablePath;
     this.filters = filters;
     this.body = body;
     this.emptyBody = emptyBody;
+    this.isLiteral = isLiteral;
+    this.literalValue = literalValue;
     this._filterFns = filters.map(f => {
       const fn = getFilter(f.name);
       return { fn, arg: f.arg };
@@ -214,7 +199,7 @@ class ForNode {
   }
 
   render(context) {
-    let rawItems = context.get(this.iterablePath);
+    let rawItems = this.isLiteral ? this.literalValue : context.get(this.iterablePath);
 
     for (const { fn, arg } of this._filterFns) {
       if (!fn) {
@@ -293,24 +278,7 @@ class WithNode {
   render(context) {
     const scope = {};
     for (const mapping of this.mappings) {
-      // The valPath may be a literal string (e.g. "Hello" with quotes) or
-      // a variable lookup (e.g. user.name). Parse quotes here.
-      const raw = mapping.valPath;
-      let value;
-      if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith('\'') && raw.endsWith('\''))) {
-        value = raw.slice(1, -1);
-      } else if (raw === 'true' || raw === 'True') {
-        value = true;
-      } else if (raw === 'false' || raw === 'False') {
-        value = false;
-      } else if (raw === 'none' || raw === 'None' || raw === 'null') {
-        value = null;
-      } else if (raw !== '' && !isNaN(Number(raw))) {
-        value = Number(raw);
-      } else {
-        value = context.get(raw);
-      }
-      scope[mapping.name] = value;
+      scope[mapping.name] = evaluateExpression(mapping.valPath, context);
     }
     // If an `as alias` was used after key=value pairs, alias the last
     // key to the alias name. This supports `{% with a=5 as answ %}` →
@@ -336,7 +304,7 @@ class CycleNode {
     const key = this.args.join(',');
     let idx = context.cycleStates.get(key) || 0;
     const token = this.args[idx % this.args.length];
-    const val = resolveValue(token, context);
+    const val = evaluateExpression(token, context);
     context.cycleStates.set(key, idx + 1);
 
     if (this.asName) {
@@ -356,7 +324,7 @@ class FirstofNode {
 
   render(context) {
     for (const arg of this.args) {
-      const val = resolveValue(arg, context);
+      const val = evaluateExpression(arg, context);
       if (val && val !== '' && val !== null && val !== undefined) {
         return String(val);
       }
@@ -365,6 +333,12 @@ class FirstofNode {
   }
 }
 
+class EndFirstofNode {
+  render(_context) {
+    return '';
+  }
+}
+
 class CommentNode {
   constructor(body) {
     this.body = body;
@@ -576,7 +550,7 @@ function parseFor(tagContent, parser) {
 
   // Parse the iterable expression to support filters: items|regroup:"category"
   const parsedIterable = parseVariableExpression(iterableExpr);
-  return new ForNode(loopVars, parsedIterable.varPath, body, emptyBody, parsedIterable.filters);
+  return new ForNode(loopVars, parsedIterable.varPath, body, emptyBody, parsedIterable.filters, parsedIterable.isLiteral, parsedIterable.literalValue);
 }
 
 function parseWith(tagContent, parser) {
@@ -658,13 +632,36 @@ function parseKeyValuePairs(content) {
         val += content[i++];
       }
       if (content[i] === quote) i++;
-      // Keep the quotes around the literal so WithNode can recognize it
       val = quote + val + quote;
     } else {
       while (i < content.length && content[i] !== ',' && !/\s/.test(content[i])) {
         val += content[i++];
       }
     }
+
+    while (i < content.length && /\s/.test(content[i])) i++;
+    if (i < content.length && content[i] === '|') {
+      val += '|';
+      i++;
+      while (i < content.length) {
+        if (/\s/.test(content[i])) { i++; continue; }
+        if (content[i] === ',') break;
+        if (content[i] === '|') { val += '|'; i++; continue; }
+        if (content[i] === ':') { val += ':'; i++; continue; }
+        if (content[i] === '"' || content[i] === '\'') {
+          const quote = content[i++];
+          val += quote;
+          while (i < content.length && content[i] !== quote) {
+            if (content[i] === '\\' && i + 1 < content.length) { val += content[i]; i++; }
+            val += content[i++];
+          }
+          if (content[i] === quote) { val += quote; i++; }
+        } else {
+          val += content[i++];
+        }
+      }
+    }
+
     tokens.push({ name: key, valPath: val });
     while (i < content.length && /\s/.test(content[i])) i++;
     if (content[i] === ',') i++;
@@ -674,17 +671,16 @@ function parseKeyValuePairs(content) {
 
 function parseCycle(tagContent, _parser) {
   const content = tagContent.slice(5).trim();
-  const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
-  const matches = content.match(argRegex) || [];
+  const parts = content.split(/\s+/).filter(Boolean);
   let asName = null;
   const args = [];
 
-  for (let i = 0; i < matches.length; i++) {
-    if (matches[i] === 'as' && i < matches.length - 1) {
-      asName = matches[i + 1];
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === 'as' && i < parts.length - 1) {
+      asName = parts[i + 1];
       break;
     }
-    args.push(matches[i]);
+    args.push(parts[i]);
   }
 
   return new CycleNode(args, asName);
@@ -692,17 +688,115 @@ function parseCycle(tagContent, _parser) {
 
 function parseFirstof(tagContent, _parser) {
   const content = tagContent.slice(8).trim();
-  const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
-  const args = (content.match(argRegex) || []).map(a => a.trim()).filter(Boolean);
+  const args = [];
+  let i = 0;
+  const len = content.length;
+
+  while (i < len) {
+    while (i < len && /\s/.test(content[i])) i++;
+    if (i >= len) break;
+
+    let expr = '';
+    if (content[i] === '"' || content[i] === '\'') {
+      const quote = content[i];
+      expr += content[i];
+      i++;
+      while (i < len && content[i] !== quote) {
+        if (content[i] === '\\' && i + 1 < len) {
+          expr += content[i];
+          i++;
+        }
+        expr += content[i];
+        i++;
+      }
+      if (i < len) {
+        expr += content[i];
+        i++;
+      }
+      while (i < len && !/\s/.test(content[i])) {
+        if (content[i] === '|') {
+          expr += content[i];
+          i++;
+          while (i < len && content[i] !== ':' && content[i] !== '|' && !/\s/.test(content[i])) {
+            expr += content[i];
+            i++;
+          }
+          if (i < len && content[i] === ':') {
+            expr += content[i];
+            i++;
+            if (i < len && (content[i] === '"' || content[i] === '\'')) {
+              const q = content[i];
+              expr += content[i];
+              i++;
+              while (i < len && content[i] !== q) {
+                if (content[i] === '\\' && i + 1 < len) {
+                  expr += content[i];
+                  i++;
+                }
+                expr += content[i];
+                i++;
+              }
+              if (i < len) {
+                expr += content[i];
+                i++;
+              }
+            } else {
+              while (i < len && content[i] !== '|' && !/\s/.test(content[i])) {
+                expr += content[i];
+                i++;
+              }
+            }
+          }
+        } else {
+          break;
+        }
+      }
+    } else {
+      while (i < len && !/\s/.test(content[i])) {
+        expr += content[i];
+        i++;
+      }
+    }
+
+    if (expr) args.push(expr);
+  }
+
   return new FirstofNode(args);
 }
 
+class ResetCycleNode {
+  constructor(key) {
+    this.key = key ? key.trim() : null;
+  }
+
+  render(context) {
+    if (!context.cycleStates) context.cycleStates = new Map();
+    if (this.key) {
+      context.cycleStates.set(this.key, 0);
+    } else {
+      context.cycleStates.clear();
+    }
+    return '';
+  }
+}
+
+function parseResetCycle(tagContent, _parser) {
+  const key = tagContent.slice(11).trim() || null;
+  return new ResetCycleNode(key);
+}
+
+function parseEndFirstof(_tagContent, _parser) {
+  return new EndFirstofNode();
+}
+
 module.exports = {
   IfNode,
   ForNode,
   WithNode,
   CycleNode,
   FirstofNode,
+  EndFirstofNode,
+  ResetCycleNode,
   CommentNode,
   AutoescapeNode,
   PartialDefNode,
@@ -718,6 +812,8 @@ module.exports = {
     comment: parseComment,
     partialdef: parsePartialDef,
     partial: parsePartial,
-    firstof: parseFirstof
+    firstof: parseFirstof,
+    endfirstof: parseEndFirstof,
+    resetcycle: parseResetCycle
   }
 };

package/src/tags/extra.js

@@ -2,20 +2,7 @@
  * Additional utility template tags: now, set, ifchanged.
  */
 
-// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
-function resolveValue(token, context) {
-  if (token === undefined || token === null) return '';
-  if (typeof token !== 'string') return token;
-  if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  return context.get(token);
-}
+const { evaluateExpression } = require('../parser');
 
 // --- {% now %} tag ---
 
@@ -25,7 +12,7 @@ class NowNode {
   }
 
   render(context) {
-    const fmt = resolveValue(this.formatExpr, context);
+    const fmt = evaluateExpression(this.formatExpr, context);
     const now = new Date();
     if (!fmt) return now.toISOString();
     const dateFilter = require('../filters');
@@ -49,7 +36,7 @@ class SetNode {
 
   render(context) {
     const name = String(this.nameExpr);
-    const value = this.valueExpr !== undefined ? resolveValue(this.valueExpr, context) : '';
+    const value = this.valueExpr !== undefined ? evaluateExpression(this.valueExpr, context) : '';
     if (name) {
       context.scopes[0][name] = value;
     }
@@ -90,7 +77,7 @@ class IfChangedNode {
   }
 
   render(context) {
-    const currentVal = this.conditionStr ? resolveValue(this.conditionStr, context) : undefined;
+    const currentVal = this.conditionStr ? evaluateExpression(this.conditionStr, context) : undefined;
 
     if (!context.ifChangedState) {
       context.ifChangedState = new Map();

package/src/tags/i18n.js

@@ -2,6 +2,7 @@
  * i18n template tags: trans, blocktrans, language.
  */
 const i18n = require('../i18n');
+const { evaluateExpression } = require('../parser');
 
 /**
  * {% trans "translation key" %}
@@ -18,19 +19,10 @@ class TransNode {
     const params = {};
     if (this.args) {
       for (const [k, v] of Object.entries(this.args)) {
-        params[k] = context.get(v);
+        params[k] = evaluateExpression(v, context);
       }
     }
-    // For unquoted keys: if the key is a variable name, resolve it
-    let key = this.key;
-    if (!key.startsWith('"') && !key.startsWith('\'') && !key.includes(' ')) {
-      const resolved = context.get(key);
-      if (typeof resolved === 'string' && resolved.length > 0) {
-        key = resolved;
-      }
-    } else {
-      key = key.slice(1, -1);
-    }
+    const key = evaluateExpression(this.key, context);
     return i18n.lookup(key, params);
   }
 }
@@ -42,10 +34,7 @@ class LanguageNode {
   }
 
   render(context) {
-    // Strip quotes
-    const lang = this.lang.startsWith('"') || this.lang.startsWith('\'')
-      ? this.lang.slice(1, -1)
-      : (context.get(this.lang) || this.lang);
+    const lang = evaluateExpression(this.lang, context);
     const previous = i18n.getLanguage();
     i18n.setLanguage(lang);
     try {
@@ -75,11 +64,11 @@ class BlockTransNode {
     // 1. Apply {% with %} mappings to a local scope
     const localParams = {};
     for (const m of this.withMappings) {
-      localParams[m.name] = context.get(m.valPath);
+      localParams[m.name] = evaluateExpression(m.valPath, context);
     }
     // 2. Apply {% plural count %} mappings
     for (const m of this.pluralMappings) {
-      localParams[m.name] = context.get(m.valPath);
+      localParams[m.name] = evaluateExpression(m.valPath, context);
     }
 
     // 3. Reassemble the full text
@@ -130,6 +119,76 @@ function parseTrans(tagContent, _parser) {
   return new TransNode(key, Object.keys(args).length ? args : null);
 }
 
+function parseTranslate(tagContent, _parser) {
+  const trimmed = tagContent.slice(9).trim(); // strip "translate"
+  const tokens = trimmed.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+
+  let keyIdx = 0;
+  if (tokens[0] && tokens[0] === 'context') {
+    keyIdx = 2;
+  }
+  const key = tokens[keyIdx] || '';
+  const args = {};
+  for (let i = keyIdx + 1; i < tokens.length; i++) {
+    const eq = tokens[i].indexOf('=');
+    if (eq > 0) {
+      const name = tokens[i].slice(0, eq);
+      let val = tokens[i].slice(eq + 1);
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+        val = val.slice(1, -1);
+      }
+      args[name] = val;
+    }
+  }
+  return new TransNode(key, Object.keys(args).length ? args : null);
+}
+
+function parseBlockTranslate(tagContent, parser) {
+  const body = parser.parse(['endblocktranslate']);
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endblocktranslate') {
+    parser.advance();
+  }
+
+  const withMappings = [];
+  const pluralMappings = [];
+  const afterTrans = tagContent.replace(/^blocktranslate\s*/, '').trim();
+  const tokens = afterTrans.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+  let i = 0;
+  if (tokens[i] === 'context') i += 2;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (tok === 'with') {
+      i++;
+      while (i < tokens.length && tokens[i].indexOf('=') > 0) {
+        const pair = tokens[i];
+        const eq = pair.indexOf('=');
+        const name = pair.slice(0, eq);
+        let val = pair.slice(eq + 1);
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+          val = val.slice(1, -1);
+        }
+        withMappings.push({ name, valPath: val });
+        i++;
+      }
+    } else if (tok === 'count') {
+      i++;
+      const countVal = tokens[i] || '1';
+      pluralMappings.push({ name: 'count', valPath: countVal });
+      i++;
+    } else {
+      i++;
+    }
+  }
+
+  return new BlockTransNode(
+    extractTextAndVars(body),
+    withMappings.length ? withMappings : extractWithMappings(body),
+    pluralMappings,
+    body
+  );
+}
+
 function parseLanguage(tagContent, parser) {
   const lang = tagContent.slice(9).trim(); // strip "language"
   const body = parser.parse(['endlanguage']);
@@ -249,8 +308,10 @@ module.exports = {
   PluralMappingNode,
   parsers: {
     trans: parseTrans,
+    translate: parseTranslate,
     language: parseLanguage,
     blocktrans: parseBlockTrans,
+    blocktranslate: parseBlockTranslate,
     plural: parsePlural
   }
 };

package/src/tags/inheritance.js

@@ -4,21 +4,7 @@
 const fs = require('fs');
 const path = require('path');
 const { Context } = require('../context');
-
-// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
-function resolveValue(token, context) {
-  if (token === undefined || token === null) return '';
-  if (typeof token !== 'string') return token;
-  if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  return context.get(token);
-}
+const { evaluateExpression } = require('../parser');
 
 class ExtendsNode {
   constructor(parentTemplateExpr) {
@@ -26,7 +12,7 @@ class ExtendsNode {
   }
 
   render(context) {
-    const parentName = resolveValue(this.parentTemplateExpr, context);
+    const parentName = evaluateExpression(this.parentTemplateExpr, context);
     if (!parentName) return '';
     context.parentTemplate = parentName;
     return '';
@@ -98,7 +84,7 @@ class IncludeNode {
   }
 
   render(context) {
-    const rawName = resolveValue(this.templateNameExpr, context);
+    const rawName = evaluateExpression(this.templateNameExpr, context);
     if (!rawName) return '';
 
     // Django-style partial selector: "home.html#card" means render
@@ -183,7 +169,7 @@ class IncludeNode {
       if (this.extraMappings && this.extraMappings.length > 0) {
         const extraScope = {};
         for (const m of this.extraMappings) {
-          extraScope[m.name] = resolveValue(m.valPath, context);
+          extraScope[m.name] = evaluateExpression(m.valPath, context);
         }
         renderCtx.push(extraScope);
         const out = partial.body.map(n => n.render(renderCtx)).join('');
@@ -198,7 +184,7 @@ class IncludeNode {
     if (this.extraMappings && this.extraMappings.length > 0) {
       const extraScope = {};
       for (const mapping of this.extraMappings) {
-        extraScope[mapping.name] = resolveValue(mapping.valPath, context);
+        extraScope[mapping.name] = evaluateExpression(mapping.valPath, context);
       }
       context.push(extraScope);
       const res = nodes.map(n => n.render(context)).join('');
@@ -308,7 +294,7 @@ function parseKeyValuePairs(str) {
         val += str[i++];
       }
       if (str[i] === quote) i++;
-      // Preserve quotes so resolveValue can recognize the literal
+      // Preserve quotes so evaluateExpression can recognize the literal
       val = quote + val + quote;
     } else {
       // Unquoted value: read until comma or whitespace