@rhinostone/swig-core 2.1.0 → 2.2.0

package/lib/engine.js

@@ -1,4 +1,5 @@
 var utils = require('./utils'),
+  ir = require('./ir'),
   backend = require('./backend'),
   cache = require('./cache');
 
@@ -79,6 +80,82 @@ exports.importNonBlocks = function (blocks, tokens) {
   });
 };
 
+/**
+ * Build an `IRExtendsDeferred` node from a parsed child template.
+ *
+ * Walks `tokens.blocks` (the parser's map of every block-level tag that
+ * appeared at top level — both `{% block %}` overrides and non-block
+ * preludes like `{% set %}`, `{% import %}`, `{% macro %}`) and:
+ *
+ *   - For each `{% block %}` token: invokes its `.compile(...)` with an
+ *     empty parents list to obtain an `IRBlock` (body is one `IRLegacyJS`
+ *     wrapping the recursively-compiled JS source — same shape sync mode
+ *     produces). The IRBlock is keyed under the block name in `childBlocks`.
+ *   - For each non-`block` block-level token: invokes its `.compile(...)`
+ *     and wraps any JS-string return in `IRLegacyJS`. The resulting IR
+ *     node is pushed onto `childIRs` (the prelude list).
+ *
+ * The backend's `IRExtendsDeferred` emit branch handles runtime parent
+ * resolution via `_swig.getTemplate` and the `_blocks` parameter contract
+ * (see `packages/swig-core/lib/backend.js`).
+ *
+ * `tokens.parent` is lifted into an `IRLiteral('string', …)` so the
+ * backend's `emitExpr` path produces a quoted JS string literal. The
+ * native parser stashes `tokens.parent` as the literal text of the
+ * extends argument after stripping enclosing quotes (lib/parser.js:273),
+ * which works for `{% extends "layout.html" %}` but for a bare
+ * identifier (`{% extends parent_var %}`) yields a pre-lowered JS
+ * source fragment such as `((typeof _ctx.parent_var !== "undefined")
+ * ? _ctx.parent_var : …)`. Embedded here as a string literal it
+ * becomes a garbage template lookup at runtime
+ * (`Template not found: /((typeof _ctx.parent_var …`). Closing the
+ * dynamic-extends gap requires the parser to stash an IRExpr on
+ * `tokens.parent` and this helper to lower it through
+ * `ir.extendsDeferred`'s `parentExpr` slot — already designed as
+ * `<IRExpr>` per the deferred IR contract.
+ *
+ * @param  {object} tokens   Parsed child template (must have `.parent`).
+ * @param  {object} options  Per-call Swig options; `options.filename` is
+ *                           used as the deferred resolveFrom.
+ * @return {object}          IRExtendsDeferred node.
+ * @private
+ */
+function buildExtendsDeferred(tokens, options) {
+  var childBlocks = {};
+  var childIRs = [];
+  utils.each(tokens.blocks, function (blockToken) {
+    var args = blockToken.args ? blockToken.args.slice(0) : [];
+    var content = blockToken.content ? blockToken.content.slice(0) : [];
+    if (blockToken.name === 'block') {
+      var blockName = args.join('');
+      var blockIR = blockToken.compile(backend.compile, args, content, [], options, blockName, blockToken);
+      if (blockIR && typeof blockIR === 'object' && typeof blockIR.type === 'string') {
+        childBlocks[blockName] = blockIR;
+      }
+      return;
+    }
+    var result = blockToken.compile(backend.compile, args, content, [], options, undefined, blockToken);
+    if (result === undefined || result === null || result === '') { return; }
+    if (typeof result === 'string') {
+      childIRs.push(ir.legacyJS(result));
+      return;
+    }
+    if (utils.isArray(result)) {
+      utils.each(result, function (n) { childIRs.push(n); });
+      return;
+    }
+    if (typeof result === 'object' && typeof result.type === 'string') {
+      childIRs.push(result);
+    }
+  });
+  return ir.extendsDeferred(
+    ir.literal('string', tokens.parent),
+    childBlocks,
+    childIRs,
+    options.filename || ''
+  );
+}
+
 /**
  * Walk a template's `extends` chain and build the parent token tree.
  * Detects circular inheritance.
@@ -307,12 +384,24 @@ exports.install = function (self, frontend) {
 
   self.precompile = function (source, options) {
     var tokens = self.parse(source, options),
-      parents = getParentsInternal(tokens, options),
+      parents,
       tpl;
 
-    if (parents.length) {
-      tokens.tokens = exports.remapBlocks(tokens.blocks, parents[0].tokens);
-      exports.importNonBlocks(tokens.blocks, tokens.tokens);
+    if (options && options.codegenMode === 'async' && tokens.parent) {
+      // Async extends — defer parent walking and block remapping to
+      // runtime via the IRExtendsDeferred emit branch in backend.js.
+      // The deferred node carries the child's blocks + non-block
+      // preludes; the backend resolves the parent via _swig.getTemplate
+      // and threads block overrides through the _blocks parameter
+      // contract.
+      parents = [];
+      tokens.tokens = [buildExtendsDeferred(tokens, options)];
+    } else {
+      parents = getParentsInternal(tokens, options);
+      if (parents.length) {
+        tokens.tokens = exports.remapBlocks(tokens.blocks, parents[0].tokens);
+        exports.importNonBlocks(tokens.blocks, tokens.tokens);
+      }
     }
 
     try {
@@ -497,6 +586,18 @@ exports.install = function (self, frontend) {
 
   self.renderFile = function (pathName, locals, cb) {
     if (cb) {
+      // Async loader opt-in: route through getTemplate when
+      // loader.async === true. Explicit flag only — load.length is
+      // not a dispatch signal (the built-in fs + memory loaders are
+      // dual-mode with length 2 and must keep the sync-cb path).
+      if (self.options.loader && self.options.loader.async === true) {
+        self.getTemplate(pathName)
+          .then(function (fn) { return fn(locals); })
+          .then(function (result) { cb(null, result.output); })
+          .catch(cb);
+        return;
+      }
+
       self.compileFile(pathName, {}, function (err, fn) {
         var result;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinostone/swig-core",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Shared IR, backend, and runtime for the @rhinostone/swig family of template engines.",
   "keywords": [
     "template",