@fluffjs/cli 0.4.4 → 0.5.0

package/IndexHtmlTransformer.js

@@ -5,35 +5,26 @@ import { Parse5Helpers } from './Parse5Helpers.js';
 import { Typeguards } from './Typeguards.js';
 export class IndexHtmlTransformer {
     static LIVE_RELOAD_SCRIPT = `(function() {
-    let firstEvent = true;
-    const es = new EventSource('/esbuild');
-    es.addEventListener('change', e => {
-        if (firstEvent) {
-            firstEvent = false;
-            return;
-        }
-        const { added, removed, updated } = JSON.parse(e.data);
-        if (!added.length && !removed.length && updated.length === 1) {
-            for (const link of document.getElementsByTagName("link")) {
-                const url = new URL(link.href);
-                if (url.host === location.host && url.pathname === updated[0]) {
-                    const next = link.cloneNode();
-                    next.href = updated[0] + '?' + Math.random().toString(36).slice(2);
-                    next.onload = () => link.remove();
-                    link.parentNode.insertBefore(next, link.nextSibling);
-                    return;
-                }
+    var protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    var url = protocol + '//' + location.host + '/_fluff/ws';
+    function connect() {
+        var ws = new WebSocket(url);
+        ws.onmessage = function(e) {
+            var data = JSON.parse(e.data);
+            if (data.type === 'reload') {
+                location.reload();
             }
-        }
-        location.reload();
-    });
+        };
+        ws.onclose = function() {
+            setTimeout(connect, 1000);
+        };
+    }
+    connect();
 })();`;
     static async transform(html, options) {
         const doc = parse5.parse(html);
         const jsSrc = options.gzScriptTag ? `${options.jsBundle}.gz` : options.jsBundle;
-        const cssSrc = options.cssBundle
-            ? (options.gzScriptTag ? `${options.cssBundle}.gz` : options.cssBundle)
-            : null;
+        const cssSrc = options.cssBundle ? (options.gzScriptTag ? `${options.cssBundle}.gz` : options.cssBundle) : null;
         const head = Parse5Helpers.findElement(doc, 'head');
         const body = Parse5Helpers.findElement(doc, 'body');
         if (head && options.inlineStyles) {
@@ -43,15 +34,13 @@ export class IndexHtmlTransformer {
         }
         if (head && cssSrc) {
             const linkEl = Parse5Helpers.createElement('link', [
-                { name: 'rel', value: 'stylesheet' },
-                { name: 'href', value: cssSrc }
+                { name: 'rel', value: 'stylesheet' }, { name: 'href', value: cssSrc }
             ]);
             Parse5Helpers.appendChild(head, linkEl);
         }
         if (body) {
             const scriptEl = Parse5Helpers.createElement('script', [
-                { name: 'type', value: 'module' },
-                { name: 'src', value: jsSrc }
+                { name: 'type', value: 'module' }, { name: 'src', value: jsSrc }
             ]);
             Parse5Helpers.appendChild(body, scriptEl);
         }
@@ -63,6 +52,9 @@ export class IndexHtmlTransformer {
         if (options.liveReload) {
             IndexHtmlTransformer.decodeScriptTextNodes(doc);
         }
+        if (options.pluginManager?.hasHook('modifyIndexHtml')) {
+            await options.pluginManager.runModifyIndexHtml(doc);
+        }
         let result = parse5.serialize(doc);
         if (options.minify) {
             result = await minify(result, {

package/PluginLoader.d.ts

@@ -0,0 +1,22 @@
+import type { FluffConfig } from './interfaces/FluffConfigInterface.js';
+import { PluginManager } from './PluginManager.js';
+export declare class PluginLoader {
+    static load(config: FluffConfig, projectRoot: string): Promise<PluginManager>;
+    private static loadPlugin;
+    private static resolvePluginPath;
+    private static tryResolveViaNx;
+    private static tryResolveNxManually;
+    private static tryResolveViaPackageJson;
+    private static tryResolveViaNodeModules;
+    private static tryResolveAsDirectPath;
+    private static tryResolveAsDirectory;
+    private static resolvePackageEntryPoint;
+    private static extractEntryFromPackageJson;
+    private static readPackageName;
+    private static readJsonFile;
+    private static safeReadDir;
+    private static findFileUpwards;
+    private static extractPlugin;
+    private static isFluffPlugin;
+}
+//# sourceMappingURL=PluginLoader.d.ts.map

package/PluginLoader.js

@@ -0,0 +1,286 @@
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import * as path from 'path';
+import { PluginManager } from './PluginManager.js';
+import { Typeguards } from './Typeguards.js';
+export class PluginLoader {
+    static async load(config, projectRoot) {
+        const manager = new PluginManager();
+        if (!config.plugins || config.plugins.length === 0) {
+            return manager;
+        }
+        for (const pluginSpec of config.plugins) {
+            const plugin = await PluginLoader.loadPlugin(pluginSpec, projectRoot);
+            manager.registerPlugin(plugin);
+        }
+        manager.resolveExecutionOrder();
+        return manager;
+    }
+    static async loadPlugin(spec, projectRoot) {
+        const modulePath = await PluginLoader.resolvePluginPath(spec, projectRoot);
+        const loaded = await import(modulePath).catch((e) => {
+            throw new Error(`Failed to load plugin '${spec}' from '${modulePath}': ${e instanceof Error ? e.message : String(e)}`);
+        });
+        const plugin = PluginLoader.extractPlugin(loaded);
+        if (!plugin) {
+            throw new Error(`Plugin '${spec}' does not export a valid FluffPlugin. ` +
+                'Expected a default export with a \'name\' property, or a default export function that returns one.');
+        }
+        return plugin;
+    }
+    static async resolvePluginPath(spec, projectRoot) {
+        const absoluteProjectRoot = path.resolve(projectRoot);
+        const nxResult = await PluginLoader.tryResolveViaNx(spec, absoluteProjectRoot);
+        if (nxResult) {
+            return nxResult;
+        }
+        const packageJsonResult = PluginLoader.tryResolveViaPackageJson(spec, absoluteProjectRoot);
+        if (packageJsonResult) {
+            return packageJsonResult;
+        }
+        const nodeModulesResult = PluginLoader.tryResolveViaNodeModules(spec, absoluteProjectRoot);
+        if (nodeModulesResult) {
+            return nodeModulesResult;
+        }
+        const directPathResult = PluginLoader.tryResolveAsDirectPath(spec, absoluteProjectRoot);
+        if (directPathResult) {
+            return directPathResult;
+        }
+        const directoryResult = PluginLoader.tryResolveAsDirectory(spec, absoluteProjectRoot);
+        if (directoryResult) {
+            return directoryResult;
+        }
+        throw new Error(`Plugin '${spec}' not found. Searched:\n` +
+            '  - nx workspace packages\n' +
+            '  - package.json overrides/resolutions\n' +
+            '  - node_modules\n' +
+            '  - direct file path\n' +
+            '  - directory with package.json');
+    }
+    static async tryResolveViaNx(spec, projectRoot) {
+        const nxJsonPath = PluginLoader.findFileUpwards('nx.json', projectRoot);
+        if (!nxJsonPath) {
+            return null;
+        }
+        const workspaceRoot = path.dirname(nxJsonPath);
+        const manualResult = PluginLoader.tryResolveNxManually(spec, workspaceRoot);
+        if (manualResult) {
+            return manualResult;
+        }
+        try {
+            const devkit = await import('@nx/devkit');
+            const graph = await devkit.createProjectGraphAsync();
+            const projectNode = graph.nodes[spec];
+            if (!projectNode) {
+                return null;
+            }
+            const nxProjectRoot = path.resolve(workspaceRoot, projectNode.data.root);
+            return PluginLoader.resolvePackageEntryPoint(nxProjectRoot);
+        }
+        catch {
+            return null;
+        }
+    }
+    static tryResolveNxManually(spec, workspaceRoot) {
+        const searchDirs = ['packages', 'apps', 'libs'];
+        for (const searchDir of searchDirs) {
+            const dirPath = path.join(workspaceRoot, searchDir);
+            if (!fs.existsSync(dirPath)) {
+                continue;
+            }
+            const entries = PluginLoader.safeReadDir(dirPath);
+            if (!entries) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const candidatePath = path.join(dirPath, entry.name);
+                const pkgJsonPath = path.join(candidatePath, 'package.json');
+                if (!fs.existsSync(pkgJsonPath)) {
+                    continue;
+                }
+                const pkgName = PluginLoader.readPackageName(pkgJsonPath);
+                if (pkgName === spec) {
+                    return PluginLoader.resolvePackageEntryPoint(candidatePath);
+                }
+            }
+        }
+        return null;
+    }
+    static tryResolveViaPackageJson(spec, projectRoot) {
+        const pkgJsonPath = PluginLoader.findFileUpwards('package.json', projectRoot);
+        if (!pkgJsonPath) {
+            return null;
+        }
+        const pkgJson = PluginLoader.readJsonFile(pkgJsonPath);
+        if (!pkgJson) {
+            return null;
+        }
+        const overridesVal = pkgJson.overrides;
+        const overrides = Typeguards.isRecord(overridesVal) ? overridesVal : undefined;
+        const resolutionsVal = pkgJson.resolutions;
+        const resolutions = Typeguards.isRecord(resolutionsVal) ? resolutionsVal : undefined;
+        const resolved = overrides?.[spec] ?? resolutions?.[spec];
+        if (typeof resolved !== 'string') {
+            return null;
+        }
+        if (resolved.startsWith('.') || resolved.startsWith('/')) {
+            const rootDir = path.dirname(pkgJsonPath);
+            const resolvedPath = path.resolve(rootDir, resolved);
+            if (fs.existsSync(resolvedPath)) {
+                if (fs.statSync(resolvedPath).isDirectory()) {
+                    return PluginLoader.resolvePackageEntryPoint(resolvedPath);
+                }
+                return resolvedPath;
+            }
+        }
+        return null;
+    }
+    static tryResolveViaNodeModules(spec, projectRoot) {
+        try {
+            const require = createRequire(path.join(projectRoot, 'noop.js'));
+            return require.resolve(spec);
+        }
+        catch {
+            return null;
+        }
+    }
+    static tryResolveAsDirectPath(spec, projectRoot) {
+        const resolved = path.isAbsolute(spec) ? spec : path.resolve(projectRoot, spec);
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            return resolved;
+        }
+        const extensions = ['.js', '.mjs', '.ts', '.mts'];
+        for (const ext of extensions) {
+            const withExt = resolved + ext;
+            if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) {
+                return withExt;
+            }
+        }
+        return null;
+    }
+    static tryResolveAsDirectory(spec, projectRoot) {
+        const resolved = path.isAbsolute(spec) ? spec : path.resolve(projectRoot, spec);
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+            return null;
+        }
+        return PluginLoader.resolvePackageEntryPoint(resolved);
+    }
+    static resolvePackageEntryPoint(dir) {
+        const pkgJsonPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgJsonPath)) {
+            const pkgJson = PluginLoader.readJsonFile(pkgJsonPath);
+            if (!pkgJson) {
+                return null;
+            }
+            const entryPoint = PluginLoader.extractEntryFromPackageJson(pkgJson);
+            if (entryPoint) {
+                const fullPath = path.resolve(dir, entryPoint);
+                if (fs.existsSync(fullPath)) {
+                    return fullPath;
+                }
+            }
+        }
+        const fallbacks = ['index.js', 'index.mjs', 'dist/index.js', 'dist/index.mjs'];
+        for (const fallback of fallbacks) {
+            const candidate = path.join(dir, fallback);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    static extractEntryFromPackageJson(pkgJson) {
+        const { exports } = pkgJson;
+        if (exports && typeof exports === 'object') {
+            if (Typeguards.isRecord(exports)) {
+                const dotExport = exports['.'];
+                if (typeof dotExport === 'string') {
+                    return dotExport;
+                }
+                if (Typeguards.isRecord(dotExport)) {
+                    if (typeof dotExport.import === 'string') {
+                        return dotExport.import;
+                    }
+                    if (typeof dotExport.default === 'string') {
+                        return dotExport.default;
+                    }
+                }
+            }
+        }
+        if (typeof pkgJson.module === 'string') {
+            return pkgJson.module;
+        }
+        if (typeof pkgJson.main === 'string') {
+            return pkgJson.main;
+        }
+        return null;
+    }
+    static readPackageName(pkgJsonPath) {
+        const content = PluginLoader.readJsonFile(pkgJsonPath);
+        if (!content) {
+            return null;
+        }
+        return typeof content.name === 'string' ? content.name : null;
+    }
+    static readJsonFile(filePath) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            if (Typeguards.isRecord(raw)) {
+                return raw;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static safeReadDir(dirPath) {
+        try {
+            return fs.readdirSync(dirPath, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+    }
+    static findFileUpwards(filename, startDir) {
+        let dir = startDir;
+        while (dir !== path.dirname(dir)) {
+            const filePath = path.join(dir, filename);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+            dir = path.dirname(dir);
+        }
+        return null;
+    }
+    static extractPlugin(loaded) {
+        if (!Typeguards.isRecord(loaded)) {
+            return null;
+        }
+        if ('default' in loaded) {
+            const defaultExport = loaded.default;
+            if (typeof defaultExport === 'function') {
+                const result = defaultExport();
+                if (PluginLoader.isFluffPlugin(result)) {
+                    return result;
+                }
+            }
+            if (PluginLoader.isFluffPlugin(defaultExport)) {
+                return defaultExport;
+            }
+        }
+        if (PluginLoader.isFluffPlugin(loaded)) {
+            return loaded;
+        }
+        return null;
+    }
+    static isFluffPlugin(value) {
+        return value !== null
+            && typeof value === 'object'
+            && 'name' in value
+            && typeof value.name === 'string';
+    }
+}

package/PluginManager.d.ts

@@ -0,0 +1,39 @@
+import type * as parse5 from 'parse5';
+import type { ClassTransformContext } from './interfaces/ClassTransformContext.js';
+import type { CodeGenContext } from './interfaces/CodeGenContext.js';
+import type { DiscoveryInfo } from './interfaces/DiscoveryInfo.js';
+import type { EntryPointContext } from './interfaces/EntryPointContext.js';
+import type { FluffConfig } from './interfaces/FluffConfigInterface.js';
+import type { FluffPlugin } from './interfaces/FluffPlugin.js';
+import type { ParsedTemplate } from './interfaces/ParsedTemplate.js';
+import type { PluginCustomTable } from './interfaces/PluginCustomTable.js';
+import type { PluginHookName } from './interfaces/PluginHookName.js';
+import type { ScopeElementConfig } from './interfaces/ScopeElementConfig.js';
+export declare class PluginManager {
+    private readonly plugins;
+    private readonly pluginsByName;
+    private readonly hookExecutionOrder;
+    registerPlugin(plugin: FluffPlugin): void;
+    resolveExecutionOrder(): void;
+    private resolveHookOrder;
+    private parseDependency;
+    private topologicalSort;
+    private getOrderedEntries;
+    runAfterConfig(config: FluffConfig, pluginConfigs: Record<string, Record<string, unknown>>): Promise<void>;
+    runAfterDiscovery(discovery: DiscoveryInfo): Promise<void>;
+    runBeforeTemplatePreProcess(fragment: parse5.DefaultTreeAdapterMap['documentFragment'], componentSelector: string): Promise<void>;
+    runAfterTemplateParse(template: ParsedTemplate, componentSelector: string): Promise<void>;
+    runAfterCodeGeneration(context: CodeGenContext): Promise<void>;
+    runBeforeClassTransform(context: ClassTransformContext): Promise<void>;
+    runModifyEntryPoint(context: EntryPointContext): Promise<void>;
+    runModifyIndexHtml(document: parse5.DefaultTreeAdapterMap['document']): Promise<void>;
+    private runHook;
+    collectRuntimeImports(): string[];
+    collectCustomTables(): PluginCustomTable[];
+    collectScopeElements(): ScopeElementConfig[];
+    internString(value: string): number;
+    internExpression(expr: string): number;
+    get hasPlugins(): boolean;
+    hasHook(hookName: PluginHookName): boolean;
+}
+//# sourceMappingURL=PluginManager.d.ts.map

package/PluginManager.js

@@ -0,0 +1,209 @@
+import { CodeGenerator } from './CodeGenerator.js';
+export class PluginManager {
+    plugins = [];
+    pluginsByName = new Map();
+    hookExecutionOrder = new Map();
+    registerPlugin(plugin) {
+        if (this.pluginsByName.has(plugin.name)) {
+            throw new Error(`Plugin '${plugin.name}' is already registered`);
+        }
+        this.plugins.push(plugin);
+        this.pluginsByName.set(plugin.name, plugin);
+    }
+    resolveExecutionOrder() {
+        this.hookExecutionOrder.clear();
+        const allHookNames = [
+            'afterConfig',
+            'afterDiscovery',
+            'beforeTemplatePreProcess',
+            'afterTemplateParse',
+            'afterCodeGeneration',
+            'beforeClassTransform',
+            'modifyEntryPoint',
+            'modifyIndexHtml',
+            'registerRuntimeImports',
+            'registerCustomTables',
+            'registerScopeElements'
+        ];
+        for (const hookName of allHookNames) {
+            const entries = this.resolveHookOrder(hookName);
+            this.hookExecutionOrder.set(hookName, entries);
+        }
+    }
+    resolveHookOrder(hookName) {
+        const participants = [];
+        for (const plugin of this.plugins) {
+            if (plugin[hookName]) {
+                participants.push({ pluginName: plugin.name, hookName, plugin });
+            }
+        }
+        if (participants.length <= 1) {
+            return participants;
+        }
+        const graph = new Map();
+        for (const entry of participants) {
+            graph.set(entry.pluginName, new Set());
+        }
+        for (const entry of participants) {
+            const deps = entry.plugin.dependencies?.[hookName];
+            if (!deps) {
+                continue;
+            }
+            for (const depSpec of deps) {
+                const parsed = this.parseDependency(depSpec);
+                if (parsed.pluginName && parsed.hookName) {
+                    if (parsed.hookName === hookName && graph.has(parsed.pluginName)) {
+                        graph.get(entry.pluginName)?.add(parsed.pluginName);
+                    }
+                }
+                else if (parsed.pluginName && !parsed.hookName) {
+                    if (graph.has(parsed.pluginName)) {
+                        graph.get(entry.pluginName)?.add(parsed.pluginName);
+                    }
+                }
+                else if (!parsed.pluginName && parsed.hookName) {
+                    if (parsed.hookName === hookName) {
+                        for (const other of participants) {
+                            if (other.pluginName !== entry.pluginName) {
+                                graph.get(entry.pluginName)?.add(other.pluginName);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return this.topologicalSort(participants, graph);
+    }
+    parseDependency(spec) {
+        if (spec.startsWith(':')) {
+            return { hookName: spec.slice(1) };
+        }
+        const colonIndex = spec.indexOf(':');
+        if (colonIndex === -1) {
+            return { pluginName: spec };
+        }
+        return {
+            pluginName: spec.slice(0, colonIndex),
+            hookName: spec.slice(colonIndex + 1)
+        };
+    }
+    topologicalSort(entries, graph) {
+        const visited = new Set();
+        const visiting = new Set();
+        const sorted = [];
+        const visit = (name) => {
+            if (visited.has(name)) {
+                return;
+            }
+            if (visiting.has(name)) {
+                const cycle = Array.from(visiting).join(' -> ') + ' -> ' + name;
+                throw new Error(`Circular plugin dependency detected: ${cycle}`);
+            }
+            visiting.add(name);
+            const deps = graph.get(name);
+            if (deps) {
+                for (const dep of deps) {
+                    visit(dep);
+                }
+            }
+            visiting.delete(name);
+            visited.add(name);
+            sorted.push(name);
+        };
+        for (const entry of entries) {
+            visit(entry.pluginName);
+        }
+        const entryMap = new Map();
+        for (const entry of entries) {
+            entryMap.set(entry.pluginName, entry);
+        }
+        const result = [];
+        for (const name of sorted) {
+            const entry = entryMap.get(name);
+            if (entry) {
+                result.push(entry);
+            }
+        }
+        return result;
+    }
+    getOrderedEntries(hookName) {
+        return this.hookExecutionOrder.get(hookName) ?? [];
+    }
+    async runAfterConfig(config, pluginConfigs) {
+        for (const entry of this.getOrderedEntries('afterConfig')) {
+            const pluginConfig = pluginConfigs[entry.pluginName] ?? {};
+            const hook = entry.plugin.afterConfig;
+            if (hook) {
+                await hook.call(entry.plugin, config, pluginConfig);
+            }
+        }
+    }
+    async runAfterDiscovery(discovery) {
+        await this.runHook('afterDiscovery', async (plugin) => plugin.afterDiscovery?.(discovery));
+    }
+    async runBeforeTemplatePreProcess(fragment, componentSelector) {
+        await this.runHook('beforeTemplatePreProcess', async (plugin) => plugin.beforeTemplatePreProcess?.(fragment, componentSelector));
+    }
+    async runAfterTemplateParse(template, componentSelector) {
+        await this.runHook('afterTemplateParse', async (plugin) => plugin.afterTemplateParse?.(template, componentSelector));
+    }
+    async runAfterCodeGeneration(context) {
+        await this.runHook('afterCodeGeneration', async (plugin) => plugin.afterCodeGeneration?.(context));
+    }
+    async runBeforeClassTransform(context) {
+        await this.runHook('beforeClassTransform', async (plugin) => plugin.beforeClassTransform?.(context));
+    }
+    async runModifyEntryPoint(context) {
+        await this.runHook('modifyEntryPoint', async (plugin) => plugin.modifyEntryPoint?.(context));
+    }
+    async runModifyIndexHtml(document) {
+        await this.runHook('modifyIndexHtml', async (plugin) => plugin.modifyIndexHtml?.(document));
+    }
+    async runHook(hookName, invoke) {
+        for (const entry of this.getOrderedEntries(hookName)) {
+            await invoke(entry.plugin);
+        }
+    }
+    collectRuntimeImports() {
+        const imports = [];
+        for (const entry of this.getOrderedEntries('registerRuntimeImports')) {
+            const hook = entry.plugin.registerRuntimeImports;
+            if (hook) {
+                imports.push(...hook.call(entry.plugin));
+            }
+        }
+        return imports;
+    }
+    collectCustomTables() {
+        const tables = [];
+        for (const entry of this.getOrderedEntries('registerCustomTables')) {
+            const hook = entry.plugin.registerCustomTables;
+            if (hook) {
+                tables.push(...hook.call(entry.plugin));
+            }
+        }
+        return tables;
+    }
+    collectScopeElements() {
+        const elements = [];
+        for (const entry of this.getOrderedEntries('registerScopeElements')) {
+            const hook = entry.plugin.registerScopeElements;
+            if (hook) {
+                elements.push(...hook.call(entry.plugin));
+            }
+        }
+        return elements;
+    }
+    internString(value) {
+        return CodeGenerator.internString(value);
+    }
+    internExpression(expr) {
+        return CodeGenerator.internExpression(expr);
+    }
+    get hasPlugins() {
+        return this.plugins.length > 0;
+    }
+    hasHook(hookName) {
+        return (this.hookExecutionOrder.get(hookName)?.length ?? 0) > 0;
+    }
+}

package/TemplateParser.d.ts

@@ -1,4 +1,5 @@
 import type { ParsedTemplate } from './interfaces/ParsedTemplate.js';
+import type { ScopeElementConfig } from './interfaces/ScopeElementConfig.js';
 export type { BindingInfo } from './interfaces/BindingInfo.js';
 export type { BreakNode } from './interfaces/BreakNode.js';
 export type { CommentNode } from './interfaces/CommentNode.js';
@@ -20,8 +21,10 @@ export declare class TemplateParser {
     private templateRefs;
     private scopeStack;
     private getterDependencyMap;
+    private scopeElements;
     private testYieldBeforeGetterDepsLookup;
     setGetterDependencyMap(map: Map<string, string[]>): void;
+    setScopeElements(configs: readonly ScopeElementConfig[]): void;
     __setTestYieldBeforeGetterDepsLookup(callback: (() => Promise<void>) | null): void;
     parse(html: string): Promise<ParsedTemplate>;
     private processNodes;
@@ -29,6 +32,8 @@ export declare class TemplateParser {
     private processConsolidatedFor;
     private processNode;
     private processElement;
+    private findScopeElementConfig;
+    private processScopedElement;
     private processForElement;
     private processSwitchElement;
     private hasChildElement;