@rhinostone/swig 2.4.2 → 2.5.0

package/lib/tags/import.js

@@ -28,7 +28,7 @@ var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousPro
  * @param {literal}     varname   Local-accessible object name to assign the macros to.
  */
 exports.compile = function (compiler, args, content, parents, options) {
-  // Phase 2 (#T22): async-codegen branch. Parse stashed `[{path}, alias]`
+  // Async-codegen branch. Parse stashed `[{path}, alias]`
   // (no macro pre-render in async mode); emit IRImportDeferred so the
   // backend's `_swig.getTemplate` + `.exports` bind happens at runtime.
   if (options && options.codegenMode === 'async') {
@@ -62,21 +62,44 @@ exports.compile = function (compiler, args, content, parents, options) {
       };
     });
 
-  // Emit the imported file's own (nested) imports first, un-namespaced, so the
-  // macros defined below can reference them by their original alias at call
-  // time. Without this, file-level imports are invisible inside macro bodies
-  // and such calls silently render empty.
+  // Re-home every name a nested import binds under THIS import's alias, so the
+  // imported file's own imports stay local to it and never leak bare into the
+  // parent _ctx: `_ctx.<boundName>` -> `_ctx.<ctx>.<boundName>`. Before this,
+  // the nested setup was emitted bare, which clobbered a same-named parent var,
+  // corrupted macros that read live _ctx after a later {% set %}, and cascaded
+  // transitively-imported aliases into the parent. Mirrors the swig-twig fix in
+  // packages/swig-twig/lib/tags/import.js; compounds across import depth with
+  // no special-casing.
+  var innerReplacements = [];
   utils.each(nestedImports, function (arg) {
-    out += arg.compiled;
+    utils.each(arg.boundNames, function (nm) {
+      innerReplacements.push({
+        ex: new RegExp('_ctx\\.' + nm + '(\\W)', 'g'),
+        re: '_ctx.' + ctx + '.' + nm + '$1'
+      });
+    });
+  });
+
+  // Emit the imported file's own (nested) imports first, re-homed under the
+  // alias, so the macros defined below resolve them at call time.
+  utils.each(nestedImports, function (arg) {
+    var c = arg.compiled;
+    utils.each(innerReplacements, function (re) {
+      c = c.replace(re.ex, re.re);
+    });
+    out += c;
   });
 
-  // Replace all occurrences of all macros in this file with
-  // proper namespaced definitions and calls
+  // Replace all occurrences of all macros in this file with proper namespaced
+  // definitions and calls, then re-home any nested-import references too.
   utils.each(macros, function (arg) {
     var c = arg.compiled;
     utils.each(replacements, function (re) {
       c = c.replace(re.ex, re.re);
     });
+    utils.each(innerReplacements, function (re) {
+      c = c.replace(re.ex, re.re);
+    });
     out += c;
   });
 
@@ -119,7 +142,11 @@ exports.parse = function (str, line, parser, types, stack, opts, swig) {
       if (token.name === 'import') {
         self.out.push({
           compiled: token.compile(compiler, token.args.slice(), token.content, [], compileOpts) + '\n',
-          isImport: true
+          isImport: true,
+          // The nested import binds one namespace alias (the tail of its
+          // parsed args). compile() re-homes it under THIS import's alias so
+          // it never leaks bare into the parent _ctx.
+          boundNames: [token.args[token.args.length - 1]]
         });
         return;
       }
@@ -127,11 +154,11 @@ exports.parse = function (str, line, parser, types, stack, opts, swig) {
         return;
       }
       macroName = token.args[0];
-      // Phase 2 (#T15): macro.compile now returns an IRMacro node
-      // rather than a JS source string. Render it through the shared
-      // backend so import.js still gets the JS source it performs
-      // regex-surgery on for namespace-prefixing. The +'\n' trailing
-      // newline matches the pre-Phase-2 compile output exactly.
+      // macro.compile returns an IRMacro node rather than a JS source
+      // string. Render it through the shared backend so import.js still
+      // gets the JS source it performs regex-surgery on for
+      // namespace-prefixing. The +'\n' trailing newline matches the
+      // legacy compile output exactly.
       out += backend.compile([token.compile(compiler, token.args, token.content, [], compileOpts)], [], compileOpts) + '\n';
       self.out.push({compiled: out, name: macroName});
     });

package/lib/tags/parent.js

@@ -35,10 +35,10 @@ exports.compile = function (compiler, args, content, parents, options, blockName
     // Silly JSLint "Strange Loop" requires return to be in a conditional
     if (breaker && parentFile !== parent.name) {
       block = parent.blocks[blockName];
-      // Phase 2: the block tag now returns `IRBlock { body: [...] }`.
-      // Splice the matched parent block's body into an IRParent node;
-      // the backend emits body verbatim plus a trailing newline for
-      // byte-identity with the pre-Phase-2 JS-string emission shape.
+      // The block tag returns `IRBlock { body: [...] }`. Splice the
+      // matched parent block's body into an IRParent node; the backend
+      // emits body verbatim plus a trailing newline for byte-identity
+      // with the legacy JS-string emission shape.
       var blockNode = block.compile(compiler, [blockName], block.content, parents.slice(i + 1), options);
       return ir.parent((blockNode && blockNode.body) ? blockNode.body.concat([ir.legacyJS('\n')]) : [ir.legacyJS('\n')]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinostone/swig",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "A simple, powerful, and extendable templating engine for node.js and browsers, similar to Django, Jinja2, and Twig.",
   "keywords": [
     "template",
@@ -21,7 +21,7 @@
     "Rhinostone <contact@gina.io>"
   ],
   "dependencies": {
-    "@rhinostone/swig-core": "2.4.2"
+    "@rhinostone/swig-core": "2.5.0"
   },
   "devDependencies": {
     "blanket": "~1.1",