@rhinostone/swig-jinja2 2.5.1 → 2.5.3

package/lib/parser.js

@@ -548,6 +548,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 inRaw = false;
@@ -698,6 +699,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;
         }
@@ -757,6 +759,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,21 +3,27 @@
  *
  * Declares a parent template for inheritance:
  *
- *   {% extends "layout.html" %}
+ *   {% extends "layout.html" %}              (static — compile-time)
+ *   {% extends parent_var %}                 (dynamic — render-time)
+ *   {% extends full if cond else partial %}  (dynamic)
  *
- * Only static string paths are supported here. Dynamic extends
- * (`{% extends some_var %}`) is rejected 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 on the sync path. Dynamic
- * extends is the async-codegen path's concern, tracked separately.
+ * 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`. This tag must 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` is a parse-time declaration carried via
- * `template.parent` metadata; no runtime code is generated for the tag.
+ * `template.parent` / `template.parentExpr` metadata; no runtime code is
+ * generated for the tag.
  */
 
 var utils = require('@rhinostone/swig-core/lib/utils');
@@ -28,20 +34,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]`.
- * Rejects anything other than a single STRING token.
+ * Parse the `{% extends %}` tag body.
+ *
+ * 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, inline-if, ...) 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 Jinja2 parser module (unused — path is a
- *                         bare string literal).
+ * @param  {object} parser The Jinja2 parser module (exposes `parseExpr`).
  * @param  {object} types  Jinja2 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) {
@@ -53,17 +65,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-jinja2",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Jinja2-syntax frontend for the @rhinostone/swig-core template engine. Part of the @rhinostone/swig multi-flavor family.",
   "keywords": [
     "template",
@@ -23,7 +23,7 @@
     "node": ">=12"
   },
   "peerDependencies": {
-    "@rhinostone/swig-core": "2.5.1"
+    "@rhinostone/swig-core": "2.5.3"
   },
   "publishConfig": {
     "access": "public"