@rhinostone/swig-twig 2.5.1 → 2.5.2

package/lib/parser.js

@@ -529,6 +529,7 @@ exports.parse = function (swig, source, opts, tags, filters) {
   var line = 1;
   var stack = [];
   var parent = null;
+  var parentExpr = null;
   var tokens = [];
   var blocks = {};
   var inVerbatim = false;
@@ -674,6 +675,7 @@ exports.parse = function (swig, source, opts, tags, filters) {
       if (token) {
         if (token.name === 'extends') {
           parent = token.args.length ? String(token.args[0]) : null;
+          parentExpr = token.irExpr && token.irExpr.file;
         } else if (token.block && !stack.length) {
           blocks[token.args.join('')] = token;
         }
@@ -733,6 +735,7 @@ exports.parse = function (swig, source, opts, tags, filters) {
   return {
     name: opts.filename,
     parent: parent,
+    parentExpr: parentExpr,
     tokens: tokens,
     blocks: blocks
   };

package/lib/tags/extends.js

@@ -3,26 +3,28 @@
  *
  * Declares a parent template for inheritance:
  *
- *   {% extends "layout.twig" %}
+ *   {% extends "layout.twig" %}      (static — resolved at compile time)
+ *   {% extends some_var %}           (dynamic — resolved at render time)
+ *   {% extends a ? "x" : "y" %}      (dynamic)
  *
- * Twig supports both static string paths (handled here) and dynamic
- * expressions (`{% extends some_var %}`, `{% extends a ? b : c %}`). This
- * session rejects dynamic extends at parse time — the engine's parent-
- * chain resolution (`engine.getParents` + `remapBlocks` +
- * `importNonBlocks`) walks the chain statically at compile time, so a
- * runtime-valued parent cannot be resolved without reworking the engine.
- * Dynamic extends is tracked for a later session; the rejection is
- * deliberate, not an oversight.
+ * A static string-literal path is pushed as the single `token.args`
+ * element; the parser's splitter lifts it onto `template.parent`, and the
+ * engine's parent-chain resolution (`engine.getParents` + `remapBlocks` +
+ * `importNonBlocks`) walks the chain statically at compile time.
  *
- * The parser's splitter reads `token.args[0]` and stashes it on
- * `template.parent` (see `packages/swig-twig/lib/parser.js` line 609).
- * This tag must therefore push the *unquoted* path as the single
- * `token.args` element.
+ * A dynamic path is lowered through `parser.parseExpr` into an IRExpr and
+ * stashed on `token.irExpr.file`; the splitter lifts it onto the sibling
+ * `template.parentExpr` slot, which the async codegen path
+ * (`buildExtendsDeferred`) prefers over the string literal and resolves at
+ * render time via `_swig.getTemplate`. Dynamic extends therefore requires
+ * an async loader (`renderFile` with a callback); on the synchronous
+ * render path a runtime-valued parent is unresolvable. Mirrors the
+ * dynamic-path lowering in `include.js`.
  *
  * Compile emits nothing — `extends.compile` returns undefined. The
  * backend's emit loop skips undefined returns. Extends is a parse-time
- * declaration carried via `template.parent` metadata; no runtime code
- * is generated for the `{% extends %}` tag itself.
+ * declaration carried via `template.parent` / `template.parentExpr`
+ * metadata; no runtime code is generated for the `{% extends %}` tag itself.
  */
 
 var utils = require('@rhinostone/swig-core/lib/utils');
@@ -34,23 +36,26 @@ exports.ends = false;
 exports.block = true;
 
 /**
- * Parse the `{% extends %}` tag body. Extracts the STRING literal path,
- * strips surrounding quotes, and stashes the result as `token.args[0]`
- * for the parser's splitter to pick up.
+ * Parse the `{% extends %}` tag body.
  *
- * Rejects anything other than a single STRING token — dynamic extends
- * (VAR, FUNCTION, expressions) is not supported in this session.
+ * A single STRING literal is stashed (quotes stripped) as `token.args[0]`
+ * for the splitter to lift onto `template.parent`. Any other expression
+ * (VAR, member access, ternary, ...) is a dynamic path: it is lowered
+ * through `parser.parseExpr` into an IRExpr on `token.irExpr.file` (the
+ * splitter lifts it onto `template.parentExpr`) and the raw source text is
+ * kept on `token.args[0]` so the sync `template.parent` string stays
+ * truthy. Mirrors `include.js`.
  *
  * @param  {string} str    Tag body.
  * @param  {number} line   Source line of the opening `{%`.
- * @param  {object} parser The Twig parser module (unused — path is a
- *                         bare string literal).
+ * @param  {object} parser The Twig parser module (exposes `parseExpr`).
  * @param  {object} types  Twig lexer token-type enum.
  * @param  {Array}  stack  Open-tag stack (unused — extends has no body).
  * @param  {object} opts   Per-call options (honors `opts.filename`).
  * @param  {object} swig   Swig instance (unused).
- * @param  {object} token  In-progress TagToken. `token.args` gets the
- *                         unquoted parent path as its single element.
+ * @param  {object} token  In-progress TagToken. Gets `token.args` (raw or
+ *                         unquoted path) and, for a dynamic path,
+ *                         `token.irExpr.file` (the lowered IRExpr).
  * @return {boolean}       Always `true` on success. Throws otherwise.
  */
 exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
@@ -62,17 +67,23 @@ exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
   if (!pathTok) {
     utils.throwError('Expected parent template path in "extends" tag', line, opts.filename);
   }
-  if (pathTok.type !== types.STRING) {
-    utils.throwError('Dynamic "extends" is not supported — parent path must be a string literal', line, opts.filename);
-  }
 
-  pos += 1;
-  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
-  if (pos < tokens.length) {
-    utils.throwError('Unexpected token "' + tokens[pos].match + '" after parent path in "extends" tag', line, opts.filename);
+  if (pathTok.type === types.STRING) {
+    pos += 1;
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    if (pos < tokens.length) {
+      utils.throwError('Unexpected token "' + tokens[pos].match + '" after parent path in "extends" tag', line, opts.filename);
+    }
+    token.args = [pathTok.match.replace(/^['"]|['"]$/g, '')];
+    return true;
   }
 
-  token.args = [pathTok.match.replace(/^['"]|['"]$/g, '')];
+  // Dynamic path: lower to an IRExpr so it resolves at render time on the
+  // async codegen path. The raw source is kept on token.args[0] so the
+  // sync template.parent string stays truthy (the async dispatch guard
+  // keys on it); buildExtendsDeferred prefers template.parentExpr.
+  token.irExpr = { file: parser.parseExpr(tokens) };
+  token.args = [utils.strip(str)];
   return true;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinostone/swig-twig",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "Twig-syntax frontend for the @rhinostone/swig-core template engine. Part of the @rhinostone/swig multi-flavor family.",
   "keywords": [
     "template",
@@ -22,7 +22,7 @@
     "node": ">=12"
   },
   "peerDependencies": {
-    "@rhinostone/swig-core": "2.5.1"
+    "@rhinostone/swig-core": "2.5.2"
   },
   "publishConfig": {
     "access": "public"