@esportsplus/template 0.34.1 → 0.35.1

package/build/index.d.ts

@@ -1,5 +1,10 @@
-import './runtime.js';
 export { default as html } from './html.js';
 export { default as render } from './render.js';
 export { default as svg } from './svg.js';
+export * from './attributes.js';
+export * from './event/index.js';
+export { ArraySlot } from './slot/array.js';
+export { EffectSlot } from './slot/effect.js';
+export { default as slot } from './slot/index.js';
 export type { Attributes, Element, Renderable } from './types.js';
+export * from './utilities.js';

package/build/index.js

@@ -1,4 +1,14 @@
-import './runtime.js';
+import { CLEANUP, STORE } from './constants.js';
+if (typeof Node !== 'undefined') {
+    Node.prototype[CLEANUP] = null;
+    Node.prototype[STORE] = null;
+}
 export { default as html } from './html.js';
 export { default as render } from './render.js';
 export { default as svg } from './svg.js';
+export * from './attributes.js';
+export * from './event/index.js';
+export { ArraySlot } from './slot/array.js';
+export { EffectSlot } from './slot/effect.js';
+export { default as slot } from './slot/index.js';
+export * from './utilities.js';

package/build/utilities.js

@@ -1,5 +1,5 @@
 import { SLOT_HTML } from './constants.js';
-let tmpl = document?.createElement('template'), txt = document?.createTextNode('');
+let tmpl = document.createElement('template'), txt = document.createTextNode('');
 const clone = typeof navigator !== 'undefined' && navigator.userAgent.includes('Firefox')
     ? document.importNode.bind(document)
     : (node, deep = true) => node.cloneNode(deep);

package/package.json

@@ -2,34 +2,28 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.26.0",
+    "@esportsplus/reactivity": "^0.27.0",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.21.0",
+    "@esportsplus/typescript": "^0.22.0",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0",
     "vite-tsconfig-paths": "^6.0.3"
   },
   "exports": {
     ".": {
-      "import": "./build/index.js",
-      "types": "./build/index.d.ts"
-    },
-    "./compiler": {
-      "import": "./build/compiler/index.js",
-      "types": "./build/compiler/index.d.ts"
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
     },
     "./compiler/tsc": {
       "types": "./build/compiler/plugins/tsc.d.ts",
-      "import": "./build/compiler/plugins/tsc.js",
-      "require": "./build/compiler/plugins/tsc.js"
+      "default": "./build/compiler/plugins/tsc.js"
     },
     "./compiler/vite": {
       "types": "./build/compiler/plugins/vite.d.ts",
-      "import": "./build/compiler/plugins/vite.js",
-      "require": "./build/compiler/plugins/vite.js"
+      "default": "./build/compiler/plugins/vite.js"
     }
   },
   "main": "./build/index.js",
@@ -41,7 +35,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.34.1",
+  "version": "0.35.1",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",

package/src/attributes.ts

@@ -61,7 +61,7 @@ function list(
         changed = false,
         delimiter = delimiters[name],
         store = (ctx ??= context(element)).store ??= {},
-        dynamic = store[name] as Set<string> | undefined;
+        dynamic = store[name] as Set<string>;
 
     if (dynamic === undefined) {
         let value = (element.getAttribute(name) || '').trim();
@@ -105,7 +105,7 @@ function list(
             }
         }
 
-        let cold = store[id] as Record<PropertyKey, true> | undefined;
+        let cold = store[id] as Record<PropertyKey, true>;
 
         if (cold !== undefined) {
             for (let part in cold) {
@@ -274,7 +274,7 @@ function task() {
 }
 
 
-const setClass = (element: Element, classlist: false | string | undefined, value: unknown) => {
+const setClass = (element: Element, classlist: false | string, value: unknown) => {
     let ctx = context(element),
         store = ctx.store ??= {};
 
@@ -298,8 +298,11 @@ const setProperty = (element: Element, name: string, value: unknown) => {
     }
 };
 
-const setProperties = function (element: Element, value: Attributes | Attributes[]) {
-    if (isObject(value)) {
+const setProperties = function (element: Element, value?: Attributes | Attributes[] | false | null | undefined) {
+    if (!value) {
+        return;
+    }
+    else if (isObject(value)) {
         for (let name in value) {
             let v = value[name];
 
@@ -317,7 +320,7 @@ const setProperties = function (element: Element, value: Attributes | Attributes
     }
 };
 
-const setStyle = (element: Element, styles: false | string | undefined, value: unknown) => {
+const setStyle = (element: Element, styles: false | string, value: unknown) => {
     let ctx = context(element),
         store = ctx.store ??= {};
 

package/src/compiler/codegen.ts

@@ -1,11 +1,8 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, uid, type Replacement } from '@esportsplus/typescript/compiler';
+import { ast, code as c, imports, uid, type Replacement } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
 import type { ReactiveCallInfo, TemplateInfo } from './ts-parser';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer';
-import {
-    COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, COMPILER_TYPES,
-    PACKAGE, PACKAGE_COMPILER
-} from '~/constants';
 import parser from './parser';
 
 
@@ -20,10 +17,10 @@ type Attribute = {
 
 type CodegenContext = {
     checker?: ts.TypeChecker;
-    hoistedFactories: Map<string, string>;
-    htmlToTemplateId: Map<string, string>;
+    imports: Map<string, string>;
     printer: ts.Printer;
     sourceFile: ts.SourceFile;
+    templates: Map<string, string>;
 };
 
 type CodegenResult = {
@@ -44,15 +41,21 @@ type ParseResult = {
 
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 
-const REGEX_PACKAGE_IMPORT = new RegExp(
-    `import\\s*\\{[^}]*\\}\\s*from\\s*['"]${PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"];?\\n?`,
-    'g'
-);
-
 
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
 
+function addImport(ctx: CodegenContext, name: string): string {
+    let alias = ctx.imports.get(name);
+
+    if (!alias) {
+        alias = uid(name);
+        ctx.imports.set(name, alias);
+    }
+
+    return alias;
+}
+
 function collectNestedTemplateReplacements(
     ctx: CodegenContext,
     node: ts.Node,
@@ -103,7 +106,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 `${addImport(ctx, 'slot')}(${anchor}, ${exprText});`;
     }
 
     if (isNestedHtmlTemplate(exprNode)) {
@@ -114,10 +117,10 @@ function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: stri
 
     switch (slotType) {
         case COMPILER_TYPES.Effect:
-            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
+            return `new ${addImport(ctx, 'EffectSlot')}(${anchor}, ${exprText});`;
 
         case COMPILER_TYPES.ArraySlot:
-            return `new ${COMPILER_NAMESPACE}.ArraySlot(${anchor}, ${exprText});`;
+            return `new ${addImport(ctx, 'ArraySlot')}(${anchor}, ${exprText});`;
 
         case COMPILER_TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
@@ -126,7 +129,7 @@ function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: stri
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
 
         default:
-            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+            return `${addImport(ctx, 'slot')}(${anchor}, ${exprText});`;
     }
 }
 
@@ -163,23 +166,30 @@ function generateTemplateCode(
             continue;
         }
 
-        let ancestorVar = root,
-            startIdx = 0;
+        let ancestor = root,
+            start = 0;
 
         for (let j = path.length - 1; j >= 0; j--) {
             let prefix = path.slice(0, j).join('.');
 
             if (nodes.has(prefix)) {
-                ancestorVar = nodes.get(prefix)!;
-                startIdx = j;
+                ancestor = nodes.get(prefix)!;
+                start = j;
                 break;
             }
         }
 
-        let name = uid('element'),
-            suffix = path.slice(startIdx).join('.');
+        let alias = addImport(ctx, 'Element'),
+            name = uid('element'),
+            segments = path.slice(start),
+            value = `${ancestor}.${segments.join('!.')}`;
+
+        // Cast root.firstChild to Element since DocumentFragment.firstChild returns ChildNode
+        if (ancestor === root && segments[0] === 'firstChild') {
+            value = value.replace(`${ancestor}.firstChild!`, `(${ancestor}.firstChild! as ${alias})`);
+        }
 
-        declarations.push(`${name} = ${ancestorVar}.${suffix} as ${COMPILER_NAMESPACE}.Element`);
+        declarations.push(`${name} = ${value} as ${alias}`);
         nodes.set(key, name);
     }
 
@@ -189,7 +199,7 @@ function generateTemplateCode(
     );
 
     for (let i = 0, n = slots.length; i < n; i++) {
-        let elementVar = slots[i].path.length === 0
+        let element = slots[i].path.length === 0
                 ? root
                 : (nodes.get(slots[i].path.join('.')) || root),
             slot = slots[i];
@@ -202,11 +212,9 @@ function generateTemplateCode(
 
                 if (name === COMPILER_TYPES.Attributes) {
                     let bindings = generateSpreadBindings(
-                            exprNodes[index],
                             exprTexts[index] || 'undefined',
-                            elementVar,
-                            ctx.checker,
-                            COMPILER_NAMESPACE
+                            element,
+                            n => addImport(ctx, n)
                         );
 
                     for (let k = 0, o = bindings.length; k < o; k++) {
@@ -218,11 +226,11 @@ function generateTemplateCode(
                 else {
                     code.push(
                         generateAttributeBinding(
-                            elementVar,
+                            element,
                             name,
                             exprTexts[index++] || 'undefined',
                             slot.attributes.statics[name] || '',
-                            COMPILER_NAMESPACE
+                            n => addImport(ctx, n)
                         )
                     );
                 }
@@ -230,7 +238,7 @@ function generateTemplateCode(
         }
         else {
             code.push(
-                generateNodeBinding(ctx, elementVar, exprTexts[index] || 'undefined', exprNodes[index])
+                generateNodeBinding(ctx, element, exprTexts[index] || 'undefined', exprNodes[index])
             );
             index++;
         }
@@ -243,41 +251,16 @@ function generateTemplateCode(
 }
 
 function getOrCreateTemplateId(ctx: CodegenContext, html: string): string {
-    let id = ctx.htmlToTemplateId.get(html);
+    let id = ctx.templates.get(html);
 
     if (!id) {
-        id = uid('tmpl');
-        ctx.hoistedFactories.set(id, html);
-        ctx.htmlToTemplateId.set(html, id);
+        id = uid('template');
+        ctx.templates.set(html, id);
     }
 
     return id;
 }
 
-function hasArraySlotImport(sourceFile: ts.SourceFile): boolean {
-    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
-        let stmt = sourceFile.statements[i];
-
-        if (!ts.isImportDeclaration(stmt) || !stmt.importClause?.namedBindings) {
-            continue;
-        }
-
-        let bindings = stmt.importClause.namedBindings;
-
-        if (!ts.isNamedImports(bindings)) {
-            continue;
-        }
-
-        for (let j = 0, m = bindings.elements.length; j < m; j++) {
-            if (bindings.elements[j].name.text === 'ArraySlot') {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
 function isNestedHtmlTemplate(expr: ts.Expression): expr is ts.TaggedTemplateExpression {
     return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT;
 }
@@ -299,15 +282,7 @@ function rewriteExpression(ctx: CodegenContext, expr: ts.Expression): string {
 }
 
 
-const addImport = (code: string): string => {
-    return `import * as ${COMPILER_NAMESPACE} from '${PACKAGE_COMPILER}';\n` + code;
-};
-
-const removePackageImport = (code: string): string => {
-    return code.replace(REGEX_PACKAGE_IMPORT, '');
-};
-
-const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker): CodegenResult => {
+const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker, existingAliases?: Map<string, string>): CodegenResult => {
     if (templates.length === 0) {
         return { changed: false, code: originalCode };
     }
@@ -331,12 +306,13 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
 
     let ctx: CodegenContext = {
             checker,
-            hoistedFactories: new Map(),
-            htmlToTemplateId: new Map(),
+            templates: new Map(),
+            imports: existingAliases ?? new Map(),
             printer,
             sourceFile
         },
-        replacements: Replacement[] = [];
+        replacements: Replacement[] = [],
+        templateAlias = addImport(ctx, 'template');
 
     for (let i = 0, n = rootTemplates.length; i < n; i++) {
         let exprTexts: string[] = [],
@@ -380,20 +356,30 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
     let changed = replacements.length > 0,
         code = c.replaceReverse(originalCode, replacements);
 
-    if (changed && ctx.hoistedFactories.size > 0) {
-        let factories: string[] = [];
+    if (changed && ctx.templates.size > 0) {
+        let aliasedImports: string[] = [],
+            factories: string[] = [];
+
+        for (let [name, alias] of ctx.imports) {
+            aliasedImports.push(`${name} as ${alias}`);
+        }
 
-        for (let [id, html] of ctx.hoistedFactories) {
-            factories.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
+        for (let [html, id] of ctx.templates) {
+            factories.push(`const ${id} = ${templateAlias}(\`${html}\`);`);
         }
 
-        code = addImport(factories.join('\n') + removePackageImport(code));
+        // Remove html entrypoint and add aliased imports
+        code = imports.modify(code, sourceFile, PACKAGE, {
+            add: new Set(aliasedImports),
+            remove: [COMPILER_ENTRYPOINT]
+        });
+        code = factories.join('\n') + '\n\n' + code;
     }
 
     return { changed, code };
 };
 
-const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourceFile: ts.SourceFile): string => {
+const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourceFile: ts.SourceFile, arraySlotAlias: string): string => {
     if (calls.length === 0) {
         return code;
     }
@@ -405,7 +391,7 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
 
         replacements.push({
             end: call.end,
-            newText: `new ${COMPILER_NAMESPACE}.ArraySlot(
+            newText: `new ${arraySlotAlias}(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
             )`,
@@ -416,14 +402,5 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
     return c.replaceReverse(code, replacements);
 };
 
-const needsArraySlotImport = (sourceFile: ts.SourceFile): boolean => {
-    return ast.hasMatch(sourceFile, n =>
-        ts.isNewExpression(n) &&
-        ts.isPropertyAccessExpression(n.expression) &&
-        n.expression.name.text === 'ArraySlot'
-    ) && !hasArraySlotImport(sourceFile);
-};
-
-
-export { addImport, generateCode, generateReactiveInlining, needsArraySlotImport };
+export { generateCode, generateReactiveInlining };
 export type { CodegenResult };

package/src/compiler/index.ts

@@ -1,8 +1,8 @@
-import { code as c } from '@esportsplus/typescript/compiler';
-import { addImport, generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants';
-import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 import { ts } from '@esportsplus/typescript';
+import { code as c, imports, uid } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '~/constants';
+import { generateCode, generateReactiveInlining } from './codegen';
+import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 
 
 type TransformResult = {
@@ -39,22 +39,23 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
 
     let changed = false,
         codegenChanged = false,
-        needsImport = false,
-        reactiveCalls = findReactiveCalls(sourceFile),
+        existingAliases = new Map<string, string>(),
+        reactiveCalls = findReactiveCalls(sourceFile, checker),
         result = code;
 
     if (reactiveCalls.length > 0) {
+        let arraySlotAlias = uid('ArraySlot');
+
         changed = true;
-        checker = undefined;
-        result = generateReactiveInlining(reactiveCalls, result, sourceFile);
+        existingAliases.set('ArraySlot', arraySlotAlias);
+        result = generateReactiveInlining(reactiveCalls, result, sourceFile, arraySlotAlias);
         sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        needsImport = needsArraySlotImport(sourceFile);
     }
 
-    let templates = findHtmlTemplates(sourceFile);
+    let templates = findHtmlTemplates(sourceFile, checker);
 
     if (templates.length > 0) {
-        let codegenResult = generateCode(templates, result, sourceFile, checker);
+        let codegenResult = generateCode(templates, result, sourceFile, checker, existingAliases);
 
         if (codegenResult.changed) {
             changed = true;
@@ -63,8 +64,15 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
         }
     }
 
-    if (needsImport && !codegenChanged) {
-        result = addImport(result);
+    // Add aliased ArraySlot import if reactive calls were processed but codegen didn't run
+    if (existingAliases.size > 0 && !codegenChanged) {
+        let aliasedImports: string[] = [];
+
+        for (let [name, alias] of existingAliases) {
+            aliasedImports.push(`${name} as ${alias}`);
+        }
+
+        result = imports.modify(result, sourceFile, PACKAGE, { add: aliasedImports });
     }
 
     if (changed) {
@@ -76,9 +84,3 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
 
 
 export { transform };
-export * from '~/attributes';
-export * from '~/event';
-export { ArraySlot } from '~/slot/array';
-export { EffectSlot } from '~/slot/effect';
-export type * from '~/types';
-export * from '~/utilities';

package/src/compiler/parser.ts

@@ -1,4 +1,4 @@
-import { COMPILER_TYPES, PACKAGE, SLOT_HTML } from '../constants';
+import { COMPILER_TYPES, PACKAGE, SLOT_HTML } from '~/constants';
 
 
 type NodePath = ('firstChild' | 'firstElementChild' | 'nextElementSibling' | 'nextSibling')[];

package/src/compiler/ts-parser.ts

@@ -1,5 +1,5 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants';
 import { ts } from '@esportsplus/typescript';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '~/constants';
 
 
 type ReactiveCallInfo = {
@@ -20,14 +20,55 @@ type TemplateInfo = {
 };
 
 
-function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[]): void {
+function isHtmlFromPackage(node: ts.Identifier, checker: ts.TypeChecker | undefined): boolean {
+    // Fast path: check identifier name first
+    if (node.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+
+    // Without checker, fall back to string-based check
+    if (!checker) {
+        return true;
+    }
+
+    let symbol = checker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+        return true;
+    }
+
+    // Follow aliases (re-exports) to find original symbol
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    let declarations = symbol.getDeclarations();
+
+    if (!declarations || declarations.length === 0) {
+        return true;
+    }
+
+    // Check if any declaration is from our package
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        let fileName = declarations[i].getSourceFile().fileName;
+
+        // Check for package in node_modules path or direct package reference
+        if (fileName.includes(PACKAGE) || fileName.includes('@esportsplus/template')) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[], checker: ts.TypeChecker | undefined): void {
     if (
         ts.isCallExpression(node) &&
         ts.isPropertyAccessExpression(node.expression) &&
         ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === COMPILER_ENTRYPOINT &&
         node.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY &&
-        node.arguments.length === 2
+        node.arguments.length === 2 &&
+        isHtmlFromPackage(node.expression.expression, checker)
     ) {
         calls.push({
             arrayArg: node.arguments[0],
@@ -38,15 +79,15 @@ function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[]): void {
         });
     }
 
-    ts.forEachChild(node, child => visitReactiveCalls(child, calls));
+    ts.forEachChild(node, child => visitReactiveCalls(child, calls, checker));
 }
 
-function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[]): void {
+function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[], checker: ts.TypeChecker | undefined): void {
     let nextDepth = (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node))
             ? depth + 1
             : depth;
 
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === COMPILER_ENTRYPOINT) {
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isHtmlFromPackage(node.tag, checker)) {
         let expressions: ts.Expression[] = [],
             literals: string[] = [],
             template = node.template;
@@ -75,14 +116,14 @@ function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[])
         });
     }
 
-    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates));
+    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates, checker));
 }
 
 
-const findHtmlTemplates = (sourceFile: ts.SourceFile): TemplateInfo[] => {
+const findHtmlTemplates = (sourceFile: ts.SourceFile, checker?: ts.TypeChecker): TemplateInfo[] => {
     let templates: TemplateInfo[] = [];
 
-    visitTemplates(sourceFile, 0, templates);
+    visitTemplates(sourceFile, 0, templates, checker);
 
     // Sort by depth descending (deepest first), then by position for stable ordering
     templates.sort((a, b) => a.depth !== b.depth ? b.depth - a.depth : a.start - b.start);
@@ -90,10 +131,10 @@ const findHtmlTemplates = (sourceFile: ts.SourceFile): TemplateInfo[] => {
     return templates;
 };
 
-const findReactiveCalls = (sourceFile: ts.SourceFile): ReactiveCallInfo[] => {
+const findReactiveCalls = (sourceFile: ts.SourceFile, checker?: ts.TypeChecker): ReactiveCallInfo[] => {
     let calls: ReactiveCallInfo[] = [];
 
-    visitReactiveCalls(sourceFile, calls);
+    visitReactiveCalls(sourceFile, calls, checker);
 
     return calls;
 };