@vue/language-core 3.1.4 → 3.1.6

package/lib/virtualCode/embeddedCodes.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueEmbeddedCode = void 0;
+exports.useEmbeddedCodes = useEmbeddedCodes;
+const alien_signals_1 = require("alien-signals");
+const muggle_string_1 = require("muggle-string");
+const buildMappings_1 = require("../utils/buildMappings");
+class VueEmbeddedCode {
+    constructor(id, lang, content) {
+        this.id = id;
+        this.lang = lang;
+        this.content = content;
+        this.linkedCodeMappings = [];
+        this.embeddedCodes = [];
+    }
+}
+exports.VueEmbeddedCode = VueEmbeddedCode;
+function useEmbeddedCodes(plugins, fileName, sfc) {
+    const getNameToBlockMap = (0, alien_signals_1.computed)(() => {
+        const blocks = {};
+        if (sfc.template) {
+            blocks[sfc.template.name] = sfc.template;
+        }
+        if (sfc.script) {
+            blocks[sfc.script.name] = sfc.script;
+        }
+        if (sfc.scriptSetup) {
+            blocks[sfc.scriptSetup.name] = sfc.scriptSetup;
+        }
+        for (const block of sfc.styles) {
+            blocks[block.name] = block;
+        }
+        for (const block of sfc.customBlocks) {
+            blocks[block.name] = block;
+        }
+        return blocks;
+    });
+    const pluginsResult = plugins.map(useEmbeddedCodesForPlugin);
+    return (0, alien_signals_1.computed)(() => {
+        const result = [];
+        const idToCodeMap = new Map();
+        const virtualCodes = pluginsResult
+            .map(getPluginResult => getPluginResult())
+            .flat()
+            .map(({ code, snapshot, mappings }) => {
+            const virtualCode = {
+                id: code.id,
+                languageId: resolveCommonLanguageId(code.lang),
+                linkedCodeMappings: code.linkedCodeMappings,
+                snapshot,
+                mappings,
+                embeddedCodes: [],
+            };
+            idToCodeMap.set(code.id, virtualCode);
+            return [code.parentCodeId, virtualCode];
+        });
+        for (const [parentCodeId, virtualCode] of virtualCodes) {
+            if (!parentCodeId) {
+                result.push(virtualCode);
+                continue;
+            }
+            const parent = idToCodeMap.get(parentCodeId);
+            if (parent) {
+                parent.embeddedCodes ??= [];
+                parent.embeddedCodes.push(virtualCode);
+            }
+            else {
+                result.push(virtualCode);
+            }
+        }
+        return result;
+    });
+    function useEmbeddedCodesForPlugin(plugin) {
+        const getMap = (0, alien_signals_1.computed)(prevMap => {
+            if (!plugin.getEmbeddedCodes) {
+                return new Map();
+            }
+            const newCodeList = plugin.getEmbeddedCodes(fileName, sfc);
+            const map = new Map();
+            for (const { id, lang } of newCodeList) {
+                const key = id + '__' + lang;
+                if (prevMap?.has(key)) {
+                    map.set(key, prevMap.get(key));
+                }
+                else {
+                    map.set(key, useEmbeddedCode(id, lang));
+                }
+            }
+            return map;
+        });
+        return (0, alien_signals_1.computed)(() => {
+            const result = [];
+            for (const generate of getMap().values()) {
+                const { code, snapshot } = generate();
+                result.push({
+                    code,
+                    snapshot,
+                    mappings: getMappingsForCode(code),
+                });
+            }
+            return result;
+        });
+    }
+    function useEmbeddedCode(id, lang) {
+        return (0, alien_signals_1.computed)(() => {
+            const content = [];
+            const code = new VueEmbeddedCode(id, lang, content);
+            for (const plugin of plugins) {
+                if (!plugin.resolveEmbeddedCode) {
+                    continue;
+                }
+                try {
+                    plugin.resolveEmbeddedCode(fileName, sfc, code);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            const newText = (0, muggle_string_1.toString)(code.content);
+            const changeRanges = new Map();
+            const snapshot = {
+                getText: (start, end) => newText.slice(start, end),
+                getLength: () => newText.length,
+                getChangeRange(oldSnapshot) {
+                    if (!changeRanges.has(oldSnapshot)) {
+                        changeRanges.set(oldSnapshot, undefined);
+                        const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+                        const changeRange = fullDiffTextChangeRange(oldText, newText);
+                        if (changeRange) {
+                            changeRanges.set(oldSnapshot, changeRange);
+                        }
+                    }
+                    return changeRanges.get(oldSnapshot);
+                },
+            };
+            return {
+                code,
+                snapshot,
+            };
+        });
+    }
+    function getMappingsForCode(code) {
+        const mappings = (0, buildMappings_1.buildMappings)(code.content.map(segment => {
+            if (typeof segment === 'string') {
+                return segment;
+            }
+            const source = segment[1];
+            if (source === undefined) {
+                return segment;
+            }
+            const block = getNameToBlockMap()[source];
+            if (!block) {
+                return segment;
+            }
+            return [
+                segment[0],
+                undefined,
+                segment[2] + block.startTagEnd,
+                segment[3],
+            ];
+        }));
+        const newMappings = [];
+        const tokenMappings = new Map();
+        for (let i = 0; i < mappings.length; i++) {
+            const mapping = mappings[i];
+            if (mapping.data.__combineToken !== undefined) {
+                const token = mapping.data.__combineToken;
+                if (tokenMappings.has(token)) {
+                    const offsetMapping = tokenMappings.get(token);
+                    offsetMapping.sourceOffsets.push(...mapping.sourceOffsets);
+                    offsetMapping.generatedOffsets.push(...mapping.generatedOffsets);
+                    offsetMapping.lengths.push(...mapping.lengths);
+                }
+                else {
+                    tokenMappings.set(token, mapping);
+                    newMappings.push(mapping);
+                }
+                continue;
+            }
+            if (mapping.data.__linkedToken !== undefined) {
+                const token = mapping.data.__linkedToken;
+                if (tokenMappings.has(token)) {
+                    const prevMapping = tokenMappings.get(token);
+                    code.linkedCodeMappings.push({
+                        sourceOffsets: [prevMapping.generatedOffsets[0]],
+                        generatedOffsets: [mapping.generatedOffsets[0]],
+                        lengths: [Number(token.description)],
+                        data: undefined,
+                    });
+                }
+                else {
+                    tokenMappings.set(token, mapping);
+                }
+                continue;
+            }
+            newMappings.push(mapping);
+        }
+        return newMappings;
+    }
+}
+function fullDiffTextChangeRange(oldText, newText) {
+    for (let start = 0; start < oldText.length && start < newText.length; start++) {
+        if (oldText[start] !== newText[start]) {
+            let end = oldText.length;
+            for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
+                if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
+                    break;
+                }
+                end--;
+            }
+            let length = end - start;
+            let newLength = length + (newText.length - oldText.length);
+            if (newLength < 0) {
+                length -= newLength;
+                newLength = 0;
+            }
+            return {
+                span: { start, length },
+                newLength,
+            };
+        }
+    }
+}
+function resolveCommonLanguageId(lang) {
+    switch (lang) {
+        case 'js':
+            return 'javascript';
+        case 'cjs':
+            return 'javascript';
+        case 'mjs':
+            return 'javascript';
+        case 'ts':
+            return 'typescript';
+        case 'cts':
+            return 'typescript';
+        case 'mts':
+            return 'typescript';
+        case 'jsx':
+            return 'javascriptreact';
+        case 'tsx':
+            return 'typescriptreact';
+        case 'pug':
+            return 'jade';
+        case 'md':
+            return 'markdown';
+    }
+    return lang;
+}
+//# sourceMappingURL=embeddedCodes.js.map

package/lib/{virtualFile/vueFile.d.ts → virtualCode/index.d.ts}

@@ -1,24 +1,24 @@
-import type { CodeInformation, Mapping, VirtualCode } from '@volar/language-core';
+import type { CodeMapping, VirtualCode } from '@volar/language-core';
+import type { SFCParseResult } from '@vue/compiler-sfc';
 import type * as ts from 'typescript';
-import type { VueCompilerOptions, VueLanguagePluginReturn } from '../types';
-import { computedSfc } from './computedSfc';
+import type { Sfc, VueCompilerOptions, VueLanguagePluginReturn } from '../types';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
     initSnapshot: ts.IScriptSnapshot;
     vueCompilerOptions: VueCompilerOptions;
-    plugins: VueLanguagePluginReturn[];
-    ts: typeof import('typescript');
     readonly id = "main";
-    readonly sfc: ReturnType<typeof computedSfc>;
     private _snapshot;
-    private _vueSfc;
+    private _parsedSfcResult;
+    private _ir;
     private _embeddedCodes;
     private _mappings;
     get snapshot(): ts.IScriptSnapshot;
-    get vueSfc(): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    get vueSfc(): SFCParseResult | undefined;
+    get sfc(): Sfc;
     get embeddedCodes(): VirtualCode[];
-    get mappings(): Mapping<CodeInformation>[];
+    get mappings(): CodeMapping[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));
     update(newSnapshot: ts.IScriptSnapshot): void;
+    private parseSfc;
 }

package/lib/virtualCode/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueVirtualCode = void 0;
+const alien_signals_1 = require("alien-signals");
+const plugins_1 = require("../plugins");
+const embeddedCodes_1 = require("./embeddedCodes");
+const ir_1 = require("./ir");
+class VueVirtualCode {
+    get snapshot() {
+        return this._snapshot();
+    }
+    get vueSfc() {
+        return this._parsedSfcResult()?.result;
+    }
+    get sfc() {
+        return this._ir;
+    }
+    get embeddedCodes() {
+        return this._embeddedCodes();
+    }
+    get mappings() {
+        return this._mappings();
+    }
+    constructor(fileName, languageId, initSnapshot, vueCompilerOptions, plugins, ts) {
+        this.fileName = fileName;
+        this.languageId = languageId;
+        this.initSnapshot = initSnapshot;
+        this.vueCompilerOptions = vueCompilerOptions;
+        this.id = 'main';
+        this._snapshot = (0, alien_signals_1.signal)(initSnapshot);
+        this._parsedSfcResult = (0, alien_signals_1.computed)(lastResult => this.parseSfc(plugins, lastResult));
+        this._ir = (0, ir_1.useIR)(ts, plugins, fileName, this._snapshot, () => this._parsedSfcResult()?.result);
+        this._embeddedCodes = (0, embeddedCodes_1.useEmbeddedCodes)(plugins, fileName, this._ir);
+        this._mappings = (0, alien_signals_1.computed)(() => {
+            return [{
+                    sourceOffsets: [0],
+                    generatedOffsets: [0],
+                    lengths: [this._snapshot().getLength()],
+                    data: plugins_1.allCodeFeatures,
+                }];
+        });
+    }
+    update(newSnapshot) {
+        this._snapshot(newSnapshot);
+    }
+    parseSfc(plugins, lastResult) {
+        const snapshot = this.snapshot;
+        if (lastResult?.plugin.updateSFC && !lastResult.result.errors.length) {
+            const change = snapshot.getChangeRange(lastResult.snapshot);
+            if (change) {
+                const newSfc = lastResult.plugin.updateSFC(lastResult.result, {
+                    start: change.span.start,
+                    end: change.span.start + change.span.length,
+                    newText: snapshot.getText(change.span.start, change.span.start + change.newLength),
+                });
+                if (newSfc) {
+                    // force dirty
+                    newSfc.descriptor = JSON.parse(JSON.stringify(newSfc.descriptor));
+                    return {
+                        snapshot,
+                        plugin: lastResult.plugin,
+                        result: newSfc,
+                    };
+                }
+            }
+        }
+        for (const plugin of plugins) {
+            const sfc = plugin.parseSFC2?.(this.fileName, this.languageId, snapshot.getText(0, snapshot.getLength()))
+                ?? plugin.parseSFC?.(this.fileName, snapshot.getText(0, snapshot.getLength()));
+            if (sfc) {
+                return {
+                    snapshot,
+                    plugin,
+                    result: sfc,
+                };
+            }
+        }
+    }
+}
+exports.VueVirtualCode = VueVirtualCode;
+//# sourceMappingURL=index.js.map

package/lib/virtualCode/ir.d.ts

@@ -0,0 +1,4 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { Sfc, VueLanguagePluginReturn } from '../types';
+export declare function useIR(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, getSnapshot: () => ts.IScriptSnapshot, getParseSfcResult: () => SFCParseResult | undefined): Sfc;

package/lib/{virtualFile/computedSfc.js → virtualCode/ir.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.templateInlineTsAsts = void 0;
-exports.computedSfc = computedSfc;
+exports.useIR = useIR;
+const CompilerDOM = require("@vue/compiler-dom");
 const alien_signals_1 = require("alien-signals");
 const signals_1 = require("../utils/signals");
-exports.templateInlineTsAsts = new WeakMap();
-function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
+const normalize_1 = require("./normalize");
+function useIR(ts, plugins, fileName, getSnapshot, getParseSfcResult) {
     const getUntrackedSnapshot = () => {
         const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
         const res = getSnapshot();
@@ -15,30 +15,25 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     const getContent = (0, alien_signals_1.computed)(() => {
         return getSnapshot().getText(0, getSnapshot().getLength());
     });
-    const getComments = (0, alien_signals_1.computed)(oldValue => {
-        const newValue = getParseResult()?.descriptor.comments ?? [];
-        if (oldValue?.length === newValue.length
-            && oldValue.every((v, i) => v === newValue[i])) {
-            return oldValue;
-        }
-        return newValue;
+    const getComments = (0, signals_1.computedArray)(() => {
+        return getParseSfcResult()?.descriptor.comments ?? [];
     });
-    const getTemplate = computedNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.template ?? undefined), (_block, base) => {
-        const compiledAst = computedTemplateAst(base);
+    const getTemplate = useNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => getParseSfcResult()?.descriptor.template ?? undefined), (_block, base) => {
+        const getParseTemplateResult = useParseTemplateResult(base);
         return mergeObject(base, {
             get ast() {
-                return compiledAst().ast;
+                return getParseTemplateResult().result?.ast;
             },
             get errors() {
-                return compiledAst().errors;
+                return getParseTemplateResult().errors;
             },
             get warnings() {
-                return compiledAst().warnings;
+                return getParseTemplateResult().warnings;
             },
         });
     });
-    const getScript = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.script ?? undefined), (block, base) => {
-        const getSrc = computedAttrValue('__src', base, block);
+    const getScript = useNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseSfcResult()?.descriptor.script ?? undefined), (block, base) => {
+        const getSrc = useAttrValue('__src', base, block);
         const getAst = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
                 const ast = plugin.compileSFCScript?.(base.lang, base.content);
@@ -57,8 +52,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             },
         });
     });
-    const getOriginalScriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
-        const getGeneric = computedAttrValue('__generic', base, block);
+    const getOriginalScriptSetup = useNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseSfcResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
+        const getGeneric = useAttrValue('__generic', base, block);
         const getAst = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
                 const ast = plugin.compileSFCScript?.(base.lang, base.content);
@@ -77,8 +72,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             },
         });
     });
-    const hasScript = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.script);
-    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.scriptSetup);
+    const hasScript = (0, alien_signals_1.computed)(() => !!getParseSfcResult()?.descriptor.script);
+    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!getParseSfcResult()?.descriptor.scriptSetup);
     const getScriptSetup = (0, alien_signals_1.computed)(() => {
         if (!hasScript() && !hasScriptSetup()) {
             // #region monkey fix: https://github.com/vuejs/language-tools/pull/2113
@@ -98,10 +93,10 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         }
         return getOriginalScriptSetup();
     });
-    const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
-        const base = computedSfcBlock('style_' + i, 'css', getBlock);
-        const getSrc = computedAttrValue('__src', base, getBlock);
-        const getModule = computedAttrValue('__module', base, getBlock);
+    const styles = (0, signals_1.reactiveArray)(() => getParseSfcResult()?.descriptor.styles ?? [], (getBlock, i) => {
+        const base = useSfcBlock('style_' + i, 'css', getBlock);
+        const getSrc = useAttrValue('__src', base, getBlock);
+        const getModule = useAttrValue('__module', base, getBlock);
         const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
         const getIr = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
@@ -111,9 +106,9 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
                 }
             }
         });
-        const getImports = (0, signals_1.computedItems)(() => getIr()?.imports ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
-        const getBindings = (0, signals_1.computedItems)(() => getIr()?.bindings ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
-        const getClassNames = (0, signals_1.computedItems)(() => getIr()?.classNames ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getImports = (0, signals_1.computedArray)(() => getIr()?.imports ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getBindings = (0, signals_1.computedArray)(() => getIr()?.bindings ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getClassNames = (0, signals_1.computedArray)(() => getIr()?.classNames ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
         return () => mergeObject(base, {
             get src() {
                 return getSrc();
@@ -135,8 +130,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             },
         });
     });
-    const customBlocks = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.customBlocks ?? []), (getBlock, i) => {
-        const base = computedSfcBlock('custom_block_' + i, 'txt', getBlock);
+    const customBlocks = (0, signals_1.reactiveArray)(() => getParseSfcResult()?.descriptor.customBlocks ?? [], (getBlock, i) => {
+        const base = useSfcBlock('custom_block_' + i, 'txt', getBlock);
         const getType = (0, alien_signals_1.computed)(() => getBlock().type);
         return () => mergeObject(base, {
             get type() {
@@ -167,68 +162,47 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             return customBlocks;
         },
     };
-    function computedTemplateAst(base) {
-        let cache;
-        let inlineTsAsts;
-        function updateInlineTsAsts(newAst, oldAst) {
-            let newTsAsts = exports.templateInlineTsAsts.get(newAst);
-            if (!newTsAsts) {
-                exports.templateInlineTsAsts.set(newAst, newTsAsts = new Map());
-            }
-            const oldTsAsts = oldAst && exports.templateInlineTsAsts.get(oldAst) || inlineTsAsts;
-            if (oldTsAsts) {
-                for (const [text, ast] of oldTsAsts) {
-                    if (!ast.__volar_used) {
-                        oldTsAsts.delete(text);
-                    }
-                    else {
-                        newTsAsts.set(text, ast);
-                        ast.__volar_used = false;
-                    }
-                }
-            }
-            inlineTsAsts = new Map(newTsAsts);
-        }
-        return (0, alien_signals_1.computed)(() => {
-            if (cache?.template === base.content) {
-                return {
-                    errors: [],
-                    warnings: [],
-                    ast: cache.result.ast,
-                };
+    function useParseTemplateResult(base) {
+        return (0, alien_signals_1.computed)(lastResult => {
+            if (lastResult?.template === base.content) {
+                return lastResult;
             }
             // incremental update
-            if (cache?.plugin.updateSFCTemplate) {
-                const change = getUntrackedSnapshot().getChangeRange(cache.snapshot);
+            if (lastResult?.result && lastResult.plugin?.updateSFCTemplate
+                && !lastResult.errors.length
+                && !lastResult.warnings.length) {
+                const change = getUntrackedSnapshot().getChangeRange(lastResult.snapshot);
                 if (change) {
                     const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
                     const templateOffset = base.startTagEnd;
                     (0, alien_signals_1.setActiveSub)(pausedSub);
                     const newText = getUntrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
-                    const newResult = cache.plugin.updateSFCTemplate(cache.result, {
+                    const newResult = lastResult.plugin.updateSFCTemplate(lastResult.result, {
                         start: change.span.start - templateOffset,
-                        end: change.span.start + change.span.length - templateOffset,
+                        end: change.span.start - templateOffset + change.span.length,
                         newText,
                     });
                     if (newResult) {
-                        updateInlineTsAsts(newResult.ast, cache.result.ast);
-                        cache.template = base.content;
-                        cache.snapshot = getUntrackedSnapshot();
-                        cache.result = newResult;
                         return {
+                            snapshot: getUntrackedSnapshot(),
+                            template: base.content,
+                            result: newResult,
+                            plugin: lastResult.plugin,
                             errors: [],
                             warnings: [],
-                            ast: newResult.ast,
                         };
                     }
                 }
             }
             const errors = [];
             const warnings = [];
+            const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset();
             let options = {
-                onError: (err) => errors.push(err),
-                onWarn: (err) => warnings.push(err),
+                onError: err => errors.push(err),
+                onWarn: err => warnings.push(err),
                 expressionPlugins: ['typescript'],
+                nodeTransforms,
+                directiveTransforms,
             };
             for (const plugin of plugins) {
                 if (plugin.resolveTemplateCompilerOptions) {
@@ -236,54 +210,49 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
                 }
             }
             for (const plugin of plugins) {
-                let result;
                 try {
-                    result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
+                    const result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
                     if (result) {
-                        updateInlineTsAsts(result.ast, cache?.result.ast);
-                    }
-                }
-                catch (e) {
-                    const err = e;
-                    errors.push(err);
-                }
-                if (result || errors.length) {
-                    if (result && !errors.length && !warnings.length) {
-                        cache = {
-                            template: base.content,
+                        (0, normalize_1.normalizeTemplateAST)(result.ast);
+                        return {
                             snapshot: getUntrackedSnapshot(),
-                            result: result,
+                            template: base.content,
+                            result,
                             plugin,
+                            errors,
+                            warnings,
                         };
                     }
-                    else {
-                        cache = undefined;
-                    }
+                }
+                catch (e) {
                     return {
-                        errors,
+                        snapshot: getUntrackedSnapshot(),
+                        template: base.content,
+                        plugin,
+                        errors: [e],
                         warnings,
-                        ast: result?.ast,
                     };
                 }
             }
             return {
+                snapshot: getUntrackedSnapshot(),
+                template: base.content,
                 errors,
                 warnings,
-                ast: undefined,
             };
         });
     }
-    function computedNullableSfcBlock(name, defaultLang, getBlock, resolve) {
+    function useNullableSfcBlock(name, defaultLang, getBlock, resolve) {
         const hasBlock = (0, alien_signals_1.computed)(() => !!getBlock());
         return (0, alien_signals_1.computed)(() => {
             if (!hasBlock()) {
                 return;
             }
             const _block = (0, alien_signals_1.computed)(() => getBlock());
-            return resolve(_block, computedSfcBlock(name, defaultLang, _block));
+            return resolve(_block, useSfcBlock(name, defaultLang, _block));
         });
     }
-    function computedSfcBlock(name, defaultLang, getBlock) {
+    function useSfcBlock(name, defaultLang, getBlock) {
         const getLang = (0, alien_signals_1.computed)(() => getBlock().lang ?? defaultLang);
         const getAttrs = (0, alien_signals_1.computed)(() => getBlock().attrs); // TODO: computed it
         const getContent = (0, alien_signals_1.computed)(() => getBlock().content);
@@ -317,7 +286,7 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             },
         };
     }
-    function computedAttrValue(key, base, getBlock) {
+    function useAttrValue(key, base, getBlock) {
         return (0, alien_signals_1.computed)(() => {
             const val = getBlock()[key];
             if (typeof val === 'object') {
@@ -333,4 +302,4 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
 function mergeObject(a, b) {
     return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
 }
-//# sourceMappingURL=computedSfc.js.map
+//# sourceMappingURL=ir.js.map

package/lib/virtualCode/normalize.d.ts

@@ -0,0 +1,2 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function normalizeTemplateAST(root: CompilerDOM.RootNode): void;