@rhinostone/swig 2.3.0 → 2.4.1

package/lib/tags/import.js

@@ -41,20 +41,38 @@ exports.compile = function (compiler, args, content, parents, options) {
     );
   }
   var ctx = args.pop(),
-    allMacros = utils.map(args, function (arg) {
+    macros = [],
+    nestedImports = [];
+
+  // The imported file may itself import macros (`{% import "x" as y %}`).
+  // Those entries are flagged `isImport` by parse() and must be emitted as-is,
+  // before — and kept out of — the macro namespace-prefixing pass below.
+  utils.each(args, function (arg) {
+    (arg.isImport ? nestedImports : macros).push(arg);
+  });
+
+  var allMacros = utils.map(macros, function (arg) {
       return arg.name;
     }).join('|'),
     out = '_ctx.' + ctx + ' = {};\n  var _output = "";\n',
-    replacements = utils.map(args, function (arg) {
+    replacements = utils.map(macros, function (arg) {
       return {
         ex: new RegExp('_ctx.' + arg.name + '(\\W)(?!' + allMacros + ')', 'g'),
         re: '_ctx.' + ctx + '.' + arg.name + '$1'
       };
     });
 
+  // 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.
+  utils.each(nestedImports, function (arg) {
+    out += arg.compiled;
+  });
+
   // Replace all occurrences of all macros in this file with
   // proper namespaced definitions and calls
-  utils.each(args, function (arg) {
+  utils.each(macros, function (arg) {
     var c = arg.compiled;
     utils.each(replacements, function (re) {
       c = c.replace(re.ex, re.re);
@@ -91,7 +109,21 @@ exports.parse = function (str, line, parser, types, stack, opts, swig) {
     utils.each(tokens, function (token) {
       var out = '',
         macroName;
-      if (!token || token.name !== 'macro' || !token.compile) {
+      if (!token || !token.compile) {
+        return;
+      }
+      // Carry the imported file's own imports through so that macros defined
+      // here which reference them resolve at call time. `token.args` is the
+      // already-parsed `[{compiled, name}, …, alias]`; slice() avoids the
+      // pop() in compile() mutating the cached token.
+      if (token.name === 'import') {
+        self.out.push({
+          compiled: token.compile(compiler, token.args.slice(), token.content, [], compileOpts) + '\n',
+          isImport: true
+        });
+        return;
+      }
+      if (token.name !== 'macro') {
         return;
       }
       macroName = token.args[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinostone/swig",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "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.3.0"
+    "@rhinostone/swig-core": "2.4.1"
   },
   "devDependencies": {
     "blanket": "~1.1",