@esportsplus/template 0.39.0 → 0.40.1

package/build/compiler/ts-analyzer.js

@@ -1,5 +1,5 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, TYPES } from './constants.js';
 function isTypeFunction(type, checker) {
     if (type.isUnion()) {
         for (let i = 0, n = type.types.length; i < n; i++) {
@@ -16,17 +16,17 @@ const analyze = (expr, checker) => {
         expr = expr.expression;
     }
     if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
-        return COMPILER_TYPES.Effect;
+        return TYPES.Effect;
     }
     if (ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
         ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === COMPILER_ENTRYPOINT &&
-        expr.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY) {
-        return COMPILER_TYPES.ArraySlot;
+        expr.expression.expression.text === ENTRYPOINT &&
+        expr.expression.name.text === ENTRYPOINT_REACTIVITY) {
+        return TYPES.ArraySlot;
     }
-    if (ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT) {
-        return COMPILER_TYPES.DocumentFragment;
+    if (ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === ENTRYPOINT) {
+        return TYPES.DocumentFragment;
     }
     if (ts.isNumericLiteral(expr) ||
         ts.isStringLiteral(expr) ||
@@ -35,30 +35,29 @@ const analyze = (expr, checker) => {
         expr.kind === ts.SyntaxKind.FalseKeyword ||
         expr.kind === ts.SyntaxKind.NullKeyword ||
         expr.kind === ts.SyntaxKind.UndefinedKeyword) {
-        return COMPILER_TYPES.Static;
+        return TYPES.Static;
     }
     if (ts.isTemplateExpression(expr)) {
-        return COMPILER_TYPES.Primitive;
+        return TYPES.Primitive;
     }
     if (ts.isConditionalExpression(expr)) {
         let whenFalse = analyze(expr.whenFalse, checker), whenTrue = analyze(expr.whenTrue, checker);
         if (whenTrue === whenFalse) {
             return whenTrue;
         }
-        if (whenTrue === COMPILER_TYPES.Effect || whenFalse === COMPILER_TYPES.Effect) {
-            return COMPILER_TYPES.Effect;
+        if (whenTrue === TYPES.Effect || whenFalse === TYPES.Effect) {
+            return TYPES.Effect;
         }
-        return COMPILER_TYPES.Unknown;
+        return TYPES.Unknown;
     }
     if (checker && (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr) || ts.isCallExpression(expr))) {
         try {
-            let type = checker.getTypeAtLocation(expr);
-            if (isTypeFunction(type, checker)) {
-                return COMPILER_TYPES.Effect;
+            if (isTypeFunction(checker.getTypeAtLocation(expr), checker)) {
+                return TYPES.Effect;
             }
         }
         catch { }
     }
-    return COMPILER_TYPES.Unknown;
+    return TYPES.Unknown;
 };
 export { analyze };

package/build/compiler/ts-parser.js

@@ -1,14 +1,14 @@
 import { ts } from '@esportsplus/typescript';
 import { imports } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '../constants.js';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, PACKAGE_NAME } from './constants.js';
 function visitReactiveCalls(node, calls, checker) {
     if (ts.isCallExpression(node) &&
         ts.isPropertyAccessExpression(node.expression) &&
         ts.isIdentifier(node.expression.expression) &&
-        node.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY &&
+        node.expression.name.text === ENTRYPOINT_REACTIVITY &&
         node.arguments.length === 2 &&
-        node.expression.expression.text === COMPILER_ENTRYPOINT &&
-        (!checker || imports.inPackage(checker, node.expression.expression, PACKAGE, COMPILER_ENTRYPOINT))) {
+        node.expression.expression.text === ENTRYPOINT &&
+        (!checker || imports.includes(checker, node.expression.expression, PACKAGE_NAME, ENTRYPOINT))) {
         calls.push({
             arrayArg: node.arguments[0],
             callbackArg: node.arguments[1],
@@ -25,8 +25,8 @@ function visitTemplates(node, depth, templates, checker) {
         : depth;
     if (ts.isTaggedTemplateExpression(node) &&
         ts.isIdentifier(node.tag) &&
-        node.tag.text === COMPILER_ENTRYPOINT &&
-        (!checker || imports.inPackage(checker, node.tag, PACKAGE, COMPILER_ENTRYPOINT))) {
+        node.tag.text === ENTRYPOINT &&
+        (!checker || imports.includes(checker, node.tag, PACKAGE_NAME, ENTRYPOINT))) {
         let { expressions, literals } = extractTemplateParts(node.template);
         templates.push({
             depth,

package/build/constants.d.ts

@@ -1,25 +1,10 @@
 declare const ARRAY_SLOT: unique symbol;
 declare const CLEANUP: unique symbol;
-declare const COMPILER_ENTRYPOINT = "html";
-declare const COMPILER_ENTRYPOINT_REACTIVITY = "reactive";
-declare const COMPILER_NAMESPACE: string;
-declare const enum COMPILER_TYPES {
-    ArraySlot = "array-slot",
-    Attributes = "attributes",
-    Attribute = "attribute",
-    DocumentFragment = "document-fragment",
-    Effect = "effect",
-    Node = "node",
-    Primitive = "primitive",
-    Static = "static",
-    Unknown = "unknown"
-}
 declare const DIRECT_ATTACH_EVENTS: Set<string>;
 declare const LIFECYCLE_EVENTS: Set<string>;
-declare const PACKAGE = "@esportsplus/template";
 declare const SLOT_HTML = "<!--$-->";
 declare const STATE_HYDRATING = 0;
 declare const STATE_NONE = 1;
 declare const STATE_WAITING = 2;
 declare const STORE: unique symbol;
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/build/constants.js

@@ -1,22 +1,5 @@
-import { uid } from '@esportsplus/typescript/compiler';
 const ARRAY_SLOT = Symbol('template.array.slot');
 const CLEANUP = Symbol('template.cleanup');
-const COMPILER_ENTRYPOINT = 'html';
-const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
-const COMPILER_NAMESPACE = uid('template');
-var COMPILER_TYPES;
-(function (COMPILER_TYPES) {
-    COMPILER_TYPES["ArraySlot"] = "array-slot";
-    COMPILER_TYPES["Attributes"] = "attributes";
-    COMPILER_TYPES["Attribute"] = "attribute";
-    COMPILER_TYPES["DocumentFragment"] = "document-fragment";
-    COMPILER_TYPES["Effect"] = "effect";
-    COMPILER_TYPES["Node"] = "node";
-    COMPILER_TYPES["Primitive"] = "primitive";
-    COMPILER_TYPES["Static"] = "static";
-    COMPILER_TYPES["Unknown"] = "unknown";
-})(COMPILER_TYPES || (COMPILER_TYPES = {}));
-;
 const DIRECT_ATTACH_EVENTS = new Set([
     'onblur',
     'onerror',
@@ -29,10 +12,9 @@ const DIRECT_ATTACH_EVENTS = new Set([
 const LIFECYCLE_EVENTS = new Set([
     'onconnect', 'ondisconnect', 'onrender', 'onresize', 'ontick'
 ]);
-const PACKAGE = '@esportsplus/template';
 const SLOT_HTML = '<!--$-->';
 const STATE_HYDRATING = 0;
 const STATE_NONE = 1;
 const STATE_WAITING = 2;
 const STORE = Symbol('template.store');
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/package.json

@@ -2,8 +2,8 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.29.1",
-    "@esportsplus/typescript": "^0.26.0",
+    "@esportsplus/reactivity": "^0.29.9",
+    "@esportsplus/typescript": "^0.27.0",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
@@ -17,6 +17,10 @@
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
     },
+    "./compiler": {
+      "types": "./build/compiler/index.d.ts",
+      "default": "./build/compiler/index.js"
+    },
     "./compiler/tsc": {
       "types": "./build/compiler/plugins/tsc.d.ts",
       "default": "./build/compiler/plugins/tsc.js"
@@ -35,7 +39,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",

package/src/compiler/codegen.ts

@@ -1,10 +1,11 @@
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { ts } from '@esportsplus/typescript';
-import { ast, uid } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS } from '~/constants';
-import { extractTemplateParts } from './ts-parser';
 import type { TemplateInfo } from './ts-parser';
 import { analyze } from './ts-analyzer';
+import { ast, uid } from '@esportsplus/typescript/compiler';
+import { DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS } from '../constants';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, TYPES } from './constants';
+import { extractTemplateParts } from './ts-parser';
+import { ts } from '@esportsplus/typescript';
 import parser from './parser';
 
 
@@ -14,7 +15,7 @@ type Attribute = {
         statics: Record<string, string>;
     };
     path: string[];
-    type: COMPILER_TYPES.Attribute;
+    type: TYPES.Attribute;
 };
 
 type CodegenContext = {
@@ -31,7 +32,7 @@ type CodegenResult = {
 
 type Node = {
     path: string[];
-    type: COMPILER_TYPES.Node;
+    type: TYPES.Node;
 };
 
 type ParseResult = {
@@ -43,31 +44,74 @@ type ParseResult = {
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
 
+function collectNestedReplacements(ctx: CodegenContext, node: ts.Node, replacements: { end: number; start: number; text: string }[]): void {
+    if (isNestedHtmlTemplate(node as ts.Expression)) {
+        replacements.push({
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: generateNestedTemplateCode(ctx, node as ts.TaggedTemplateExpression)
+        });
+
+        return;
+    }
+
+    if (isReactiveCall(node as ts.Expression)) {
+        let call = node as ts.CallExpression;
+
+        replacements.push({
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: `new ${NAMESPACE}.ArraySlot(${rewriteExpression(ctx, call.arguments[0] as ts.Expression)}, ${rewriteExpression(ctx, call.arguments[1] as ts.Expression)})`
+        });
+
+        return;
+    }
+
+    ts.forEachChild(node, child => collectNestedReplacements(ctx, child, replacements));
+}
+
+function discoverTemplatesInExpression(ctx: CodegenContext, node: ts.Node): void {
+    if (isNestedHtmlTemplate(node as ts.Expression)) {
+        let { expressions, literals } = extractTemplateParts((node as ts.TaggedTemplateExpression).template),
+            parsed = parser.parse(literals) as ParseResult;
+
+        getOrCreateTemplateId(ctx, parsed.html);
+
+        for (let i = 0, n = expressions.length; i < n; i++) {
+            discoverTemplatesInExpression(ctx, expressions[i]);
+        }
+
+        return;
+    }
+
+    ts.forEachChild(node, child => discoverTemplatesInExpression(ctx, child));
+}
+
 function generateAttributeBinding(element: string, name: string, expr: string, staticValue: string): string {
     if (name.startsWith('on') && name.length > 2) {
         let event = name.slice(2).toLowerCase(),
             key = name.toLowerCase();
 
         if (LIFECYCLE_EVENTS.has(key)) {
-            return `${COMPILER_NAMESPACE}.${key}(${element}, ${expr});`;
+            return `${NAMESPACE}.${key}(${element}, ${expr});`;
         }
 
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${COMPILER_NAMESPACE}.on(${element}, '${event}', ${expr});`;
+            return `${NAMESPACE}.on(${element}, '${event}', ${expr});`;
         }
 
-        return `${COMPILER_NAMESPACE}.delegate(${element}, '${event}', ${expr});`;
+        return `${NAMESPACE}.delegate(${element}, '${event}', ${expr});`;
     }
 
     if (name === 'class') {
-        return `${COMPILER_NAMESPACE}.setClass(${element}, '${staticValue}', ${expr});`;
+        return `${NAMESPACE}.setClass(${element}, '${staticValue}', ${expr});`;
     }
 
     if (name === 'style') {
-        return `${COMPILER_NAMESPACE}.setStyle(${element}, '${staticValue}', ${expr});`;
+        return `${NAMESPACE}.setStyle(${element}, '${staticValue}', ${expr});`;
     }
 
-    return `${COMPILER_NAMESPACE}.setProperty(${element}, '${name}', ${expr});`;
+    return `${NAMESPACE}.setProperty(${element}, '${name}', ${expr});`;
 }
 
 function generateNestedTemplateCode(ctx: CodegenContext, node: ts.TaggedTemplateExpression): string {
@@ -89,7 +133,7 @@ function generateNestedTemplateCode(ctx: CodegenContext, node: ts.TaggedTemplate
 
 function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: string, exprNode: ts.Expression | undefined): string {
     if (!exprNode) {
-        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+        return `${NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 
     if (isNestedHtmlTemplate(exprNode)) {
@@ -97,20 +141,20 @@ function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: stri
     }
 
     switch (analyze(exprNode, ctx.checker)) {
-        case COMPILER_TYPES.ArraySlot:
-            return `${anchor}.parentNode!.insertBefore(new ${COMPILER_NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
+        case TYPES.ArraySlot:
+            return `${anchor}.parentNode!.insertBefore(new ${NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
 
-        case COMPILER_TYPES.DocumentFragment:
+        case TYPES.DocumentFragment:
             return `${anchor}.parentNode!.insertBefore(${exprText}, ${anchor});`;
 
-        case COMPILER_TYPES.Effect:
-            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
+        case TYPES.Effect:
+            return `new ${NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
 
-        case COMPILER_TYPES.Static:
+        case TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
 
         default:
-            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+            return `${NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 }
 
@@ -166,17 +210,15 @@ function generateTemplateCode(
             value = `${ancestor}.${segments.join('!.')}`;
 
         if (ancestor === root && segments[0] === 'firstChild') {
-            value = value.replace(`${ancestor}.firstChild!`, `(${ancestor}.firstChild! as ${COMPILER_NAMESPACE}.Element)`);
+            value = value.replace(`${ancestor}.firstChild!`, `(${root}.firstChild! as ${NAMESPACE}.Element)`);
         }
 
-        declarations.push(`${name} = ${value} as ${COMPILER_NAMESPACE}.Element`);
+        declarations.push(`${name} = ${value} as ${NAMESPACE}.Element`);
         nodes.set(key, name);
     }
 
-    code.push(
-        isArrowBody ? '{' : `(() => {`,
-        `let ${declarations.join(',\n')};`
-    );
+    code.push(isArrowBody ? '{' : `(() => {`);
+    code.push(`let ${declarations.join(',\n')};`);
 
     for (let i = 0, n = slots.length; i < n; i++) {
         let element = slots[i].path.length === 0
@@ -184,15 +226,15 @@ function generateTemplateCode(
                 : (nodes.get(slots[i].path.join('.')) || root),
             slot = slots[i];
 
-        if (slot.type === COMPILER_TYPES.Attribute) {
+        if (slot.type === TYPES.Attribute) {
             let names = slot.attributes.names;
 
             for (let j = 0, m = names.length; j < m; j++) {
                 let name = names[j];
 
-                if (name === COMPILER_TYPES.Attributes) {
+                if (name === TYPES.Attributes) {
                     code.push(
-                        `${COMPILER_NAMESPACE}.setProperties(${element}, ${exprTexts[index] || 'undefined'});`
+                        `${NAMESPACE}.setProperties(${element}, ${exprTexts[index] || 'undefined'});`
                     );
                     index++;
                 }
@@ -233,21 +275,21 @@ function getOrCreateTemplateId(ctx: CodegenContext, html: string): string {
     return id;
 }
 
-function isNestedHtmlTemplate(expr: ts.Expression): expr is ts.TaggedTemplateExpression {
-    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT;
-}
-
 function isArrowExpressionBody(node: ts.Node): boolean {
     return ts.isArrowFunction(node.parent) && (node.parent as ts.ArrowFunction).body === node;
 }
 
+function isNestedHtmlTemplate(expr: ts.Expression): expr is ts.TaggedTemplateExpression {
+    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === ENTRYPOINT;
+}
+
 function isReactiveCall(expr: ts.Expression): expr is ts.CallExpression {
     return (
         ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
         ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === COMPILER_ENTRYPOINT &&
-        expr.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY
+        expr.expression.expression.text === ENTRYPOINT &&
+        expr.expression.name.text === ENTRYPOINT_REACTIVITY
     );
 }
 
@@ -256,138 +298,29 @@ function rewriteExpression(ctx: CodegenContext, expr: ts.Expression): string {
         return generateNestedTemplateCode(ctx, expr);
     }
 
-    // Returns just args "array, callback" - for direct slot usage where generateNodeBinding wraps it
     if (isReactiveCall(expr)) {
-        return `
-            ${printer.printNode(ts.EmitHint.Expression, expr.arguments[0], ctx.sourceFile)},
-            ${rewriteExpression(ctx, expr.arguments[1] as ts.Expression)}
-        `;
+        return `${rewriteExpression(ctx, expr.arguments[0] as ts.Expression)}, ${rewriteExpression(ctx, expr.arguments[1] as ts.Expression)}`;
     }
 
-    if (!ast.hasMatch(expr, n => isNestedHtmlTemplate(n as ts.Expression) || isReactiveCall(n as ts.Expression))) {
+    if (!ast.test(expr, n => isNestedHtmlTemplate(n as ts.Expression) || isReactiveCall(n as ts.Expression))) {
         return printer.printNode(ts.EmitHint.Expression, expr, ctx.sourceFile);
     }
 
-    return walkExpression(ctx, expr);
-}
+    let exprStart = expr.getStart(ctx.sourceFile),
+        replacements: { end: number; start: number; text: string }[] = [],
+        text = expr.getText(ctx.sourceFile);
 
-function walkExpression(ctx: CodegenContext, node: ts.Node): string {
-    // Intercept special nodes
-    if (isNestedHtmlTemplate(node as ts.Expression)) {
-        return generateNestedTemplateCode(ctx, node as ts.TaggedTemplateExpression);
-    }
+    ts.forEachChild(expr, child => collectNestedReplacements(ctx, child, replacements));
 
-    if (isReactiveCall(node as ts.Expression)) {
-        let call = node as ts.CallExpression;
-
-        return `new ${COMPILER_NAMESPACE}.ArraySlot(${printer.printNode(ts.EmitHint.Expression, call.arguments[0], ctx.sourceFile)}, ${rewriteExpression(ctx, call.arguments[1] as ts.Expression)})`;
-    }
-
-    // No nested constructs - use printer
-    if (!ast.hasMatch(node, n => isNestedHtmlTemplate(n as ts.Expression) || isReactiveCall(n as ts.Expression))) {
-        return printer.printNode(ts.EmitHint.Expression, node as ts.Expression, ctx.sourceFile);
-    }
+    replacements.sort((a, b) => b.start - a.start);
 
-    // Recursive handling by node type
-    if (ts.isConditionalExpression(node)) {
-        return `${walkExpression(ctx, node.condition)} ? ${walkExpression(ctx, node.whenTrue)} : ${walkExpression(ctx, node.whenFalse)}`;
-    }
-
-    if (ts.isBinaryExpression(node)) {
-        return `${walkExpression(ctx, node.left)} ${node.operatorToken.getText(ctx.sourceFile)} ${walkExpression(ctx, node.right)}`;
-    }
-
-    if (ts.isCallExpression(node)) {
-        let args: string[] = [];
-
-        for (let i = 0, n = node.arguments.length; i < n; i++) {
-            args.push(walkExpression(ctx, node.arguments[i]));
-        }
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
 
-        return `${walkExpression(ctx, node.expression)}(${args.join(', ')})`;
+        text = text.slice(0, r.start - exprStart) + r.text + text.slice(r.end - exprStart);
     }
 
-    if (ts.isPropertyAccessExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}.${node.name.text}`;
-    }
-
-    if (ts.isElementAccessExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}[${walkExpression(ctx, node.argumentExpression)}]`;
-    }
-
-    if (ts.isParenthesizedExpression(node)) {
-        return `(${walkExpression(ctx, node.expression)})`;
-    }
-
-    if (ts.isArrowFunction(node)) {
-        return `(${node.parameters.map(p => p.getText(ctx.sourceFile)).join(', ')}) => ${
-            ts.isBlock(node.body) ? node.body.getText(ctx.sourceFile) : walkExpression(ctx, node.body)
-        }`;
-    }
-
-    if (ts.isArrayLiteralExpression(node)) {
-        let elements: string[] = [];
-
-        for (let i = 0, n = node.elements.length; i < n; i++) {
-            elements.push( walkExpression(ctx, node.elements[i]) );
-        }
-
-        return `[${elements.join(', ')}]`;
-    }
-
-    if (ts.isObjectLiteralExpression(node)) {
-        let properties: string[] = [];
-
-        for (let i = 0, n = node.properties.length; i < n; i++) {
-            let prop = node.properties[i];
-
-            if (ts.isPropertyAssignment(prop)) {
-                properties.push(`${prop.name.getText(ctx.sourceFile)}: ${walkExpression(ctx, prop.initializer)}`);
-            }
-            else if (ts.isShorthandPropertyAssignment(prop)) {
-                properties.push(prop.name.text);
-            }
-            else if (ts.isSpreadAssignment(prop)) {
-                properties.push(`...${walkExpression(ctx, prop.expression)}`);
-            }
-            else {
-                properties.push(prop.getText(ctx.sourceFile));
-            }
-        }
-
-        return `{ ${properties.join(', ')} }`;
-    }
-
-    if (ts.isPrefixUnaryExpression(node)) {
-        return `${ts.tokenToString(node.operator)}${walkExpression(ctx, node.operand)}`;
-    }
-
-    if (ts.isPostfixUnaryExpression(node)) {
-        return `${walkExpression(ctx, node.operand)}${ts.tokenToString(node.operator)}`;
-    }
-
-    if (ts.isTemplateExpression(node)) {
-        let parts = [node.head.text];
-
-        for (let i = 0, n = node.templateSpans.length; i < n; i++) {
-            let span = node.templateSpans[i];
-
-            parts.push('${' + walkExpression(ctx, span.expression) + '}' + span.literal.text);
-        }
-
-        return '`' + parts.join('') + '`';
-    }
-
-    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-        return walkExpression(ctx, node.expression);
-    }
-
-    if (ts.isNonNullExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}!`;
-    }
-
-    // Fallback - use printer
-    return printer.printNode(ts.EmitHint.Expression, node as ts.Expression, ctx.sourceFile);
+    return text;
 }
 
 
@@ -412,9 +345,9 @@ const generateCode = (templates: TemplateInfo[], sourceFile: ts.SourceFile, chec
         }
     }
 
-    let rootTemplates = templates.filter(t => !ast.inRange(ranges, t.node.getStart(sourceFile), t.node.end));
+    let root = templates.filter(t => !ast.inRange(ranges, t.node.getStart(sourceFile), t.node.end));
 
-    if (rootTemplates.length === 0) {
+    if (root.length === 0) {
         return result;
     }
 
@@ -424,46 +357,47 @@ const generateCode = (templates: TemplateInfo[], sourceFile: ts.SourceFile, chec
             templates: result.templates
         };
 
-    for (let i = 0, n = rootTemplates.length; i < n; i++) {
-        let template = rootTemplates[i];
-
-        result.replacements.push({
-            generate: (sf) => {
-                let exprTexts: string[] = [],
-                    localCtx: CodegenContext = {
-                        checker,
-                        sourceFile: sf,
-                        templates: ctx.templates
-                    },
-                    parsed = parser.parse(template.literals) as ParseResult;
-
-                for (let j = 0, m = template.expressions.length; j < m; j++) {
-                    exprTexts.push(rewriteExpression(localCtx, template.expressions[j]));
-                }
+    for (let i = 0, n = root.length; i < n; i++) {
+        let exprTexts: string[] = [],
+            parsed = parser.parse(root[i].literals) as ParseResult,
+            template = root[i];
 
-                // Zero-param arrow with no slots → just return template ID
-                if (
-                    isArrowExpressionBody(template.node) &&
-                    (template.node.parent as ts.ArrowFunction).parameters.length === 0 &&
-                    (!parsed.slots || parsed.slots.length === 0)
-                ) {
-                    return getOrCreateTemplateId(localCtx, parsed.html);
-                }
+        for (let j = 0, m = template.expressions.length; j < m; j++) {
+            exprTexts.push(rewriteExpression(ctx, template.expressions[j]));
+        }
 
-                return generateTemplateCode(
-                    localCtx,
-                    parsed,
-                    exprTexts,
-                    template.expressions,
-                    template.node
-                );
-            },
-            node: template.node
-        });
+        if (
+            isArrowExpressionBody(template.node) &&
+            (template.node.parent as ts.ArrowFunction).parameters.length === 0 &&
+            (!parsed.slots || parsed.slots.length === 0)
+        ) {
+            let code = getOrCreateTemplateId(ctx, parsed.html);
+
+            result.replacements.push({
+                generate: () => code,
+                node: template.node
+            });
+        }
+        else {
+            let code = generateTemplateCode(ctx, parsed, exprTexts, template.expressions, template.node);
+
+            result.replacements.push({
+                generate: () => code,
+                node: template.node
+            });
+        }
+    }
+
+    for (let i = 0, n = templates.length; i < n; i++) {
+        getOrCreateTemplateId(ctx, parser.parse(templates[i].literals).html);
+
+        for (let j = 0, m = templates[i].expressions.length; j < m; j++) {
+            discoverTemplatesInExpression(ctx, templates[i].expressions[j]);
+        }
     }
 
     for (let [html, id] of ctx.templates) {
-        result.prepend.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
+        result.prepend.push(`const ${id} = ${NAMESPACE}.template(\`${html}\`);`);
     }
 
     return result;