@vue/language-core 2.2.0 → 2.2.2

package/lib/utils/ts.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
+exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
 exports.setupGlobalTypes = setupGlobalTypes;
 const shared_1 = require("@vue/shared");
@@ -11,17 +13,17 @@ const languagePlugin_1 = require("../languagePlugin");
 function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json', skipGlobalTypesSetup = false) {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
-    let vueOptions = {};
+    const resolver = new CompilerOptionsResolver();
     for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
         try {
-            vueOptions = {
-                ...vueOptions,
-                ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
-            };
+            const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
+            const obj = ts.convertToObject(configFile, []);
+            const rawOptions = obj?.vueCompilerOptions ?? {};
+            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
         }
         catch (err) { }
     }
-    const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+    const resolvedVueOptions = resolver.build();
     if (skipGlobalTypesSetup) {
         resolvedVueOptions.__setupedGlobalTypes = true;
     }
@@ -48,17 +50,17 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
         const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
         const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
         ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath);
-        let vueOptions = {};
+        const resolver = new CompilerOptionsResolver();
         for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
             try {
-                vueOptions = {
-                    ...vueOptions,
-                    ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
-                };
+                const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
+                const obj = ts.convertToObject(configFile, []);
+                const rawOptions = obj?.vueCompilerOptions ?? {};
+                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
             }
             catch (err) { }
         }
-        const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+        const resolvedVueOptions = resolver.build();
         if (skipGlobalTypesSetup) {
             resolvedVueOptions.__setupedGlobalTypes = true;
         }
@@ -85,7 +87,7 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
         return {
             fileNames: [],
             options: {},
-            vueOptions: resolveVueCompilerOptions({}),
+            vueOptions: getDefaultCompilerOptions(),
             errors: [],
         };
     }
@@ -110,67 +112,100 @@ function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
         extendConfigPaths,
     };
 }
-function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
-    const folder = path_browserify_1.posix.dirname(tsConfigSourceFile.fileName);
-    const obj = ts.convertToObject(tsConfigSourceFile, []);
-    const rawOptions = obj?.vueCompilerOptions ?? {};
-    const result = {
-        ...rawOptions,
-    };
-    const target = rawOptions.target ?? 'auto';
-    if (target === 'auto') {
-        const resolvedPath = resolvePath('vue/package.json');
-        if (resolvedPath) {
-            const vuePackageJson = require(resolvedPath);
-            const versionNumbers = vuePackageJson.version.split('.');
-            result.target = Number(versionNumbers[0] + '.' + versionNumbers[1]);
+class CompilerOptionsResolver {
+    constructor() {
+        this.options = {};
+        this.plugins = [];
+    }
+    addConfig(options, rootDir) {
+        for (const key in options) {
+            switch (key) {
+                case 'target':
+                    const target = options.target;
+                    if (typeof target === 'string') {
+                        this.target = findVueVersion(rootDir);
+                    }
+                    else {
+                        this.target = target;
+                    }
+                    break;
+                case 'plugins':
+                    this.plugins = (options.plugins ?? [])
+                        .map((pluginPath) => {
+                        try {
+                            const resolvedPath = resolvePath(pluginPath, rootDir);
+                            if (resolvedPath) {
+                                const plugin = require(resolvedPath);
+                                plugin.__moduleName = pluginPath;
+                                return plugin;
+                            }
+                            else {
+                                console.warn('[Vue] Load plugin failed:', pluginPath);
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
+                        }
+                        return [];
+                    });
+                    break;
+                default:
+                    // @ts-expect-error
+                    this.options[key] = options[key];
+                    break;
+            }
         }
-        else {
-            // console.warn('Load vue/package.json failed from', folder);
+        if (this.target === undefined) {
+            this.fallbackTarget = findVueVersion(rootDir);
         }
     }
-    else {
-        result.target = target;
+    build(defaults) {
+        const target = this.target ?? this.fallbackTarget;
+        defaults ??= getDefaultCompilerOptions(target, this.options.lib, this.options.strictTemplates);
+        return {
+            ...defaults,
+            ...this.options,
+            plugins: this.plugins,
+            macros: {
+                ...defaults.macros,
+                ...this.options.macros,
+            },
+            composables: {
+                ...defaults.composables,
+                ...this.options.composables,
+            },
+            // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+            // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
+            experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
+        };
     }
-    if (rawOptions.plugins) {
-        const plugins = rawOptions.plugins
-            .map((pluginPath) => {
-            try {
-                const resolvedPath = resolvePath(pluginPath);
-                if (resolvedPath) {
-                    const plugin = require(resolvedPath);
-                    plugin.__moduleName = pluginPath;
-                    return plugin;
-                }
-                else {
-                    console.warn('[Vue] Load plugin failed:', pluginPath);
-                }
-            }
-            catch (error) {
-                console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
-            }
-            return [];
-        });
-        result.plugins = plugins;
+}
+exports.CompilerOptionsResolver = CompilerOptionsResolver;
+function findVueVersion(rootDir) {
+    const resolvedPath = resolvePath('vue/package.json', rootDir);
+    if (resolvedPath) {
+        const vuePackageJson = require(resolvedPath);
+        const versionNumbers = vuePackageJson.version.split('.');
+        return Number(versionNumbers[0] + '.' + versionNumbers[1]);
     }
-    return result;
-    function resolvePath(scriptPath) {
-        try {
-            if (require?.resolve) {
-                return require.resolve(scriptPath, { paths: [folder] });
-            }
-            else {
-                // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
-            }
+    else {
+        // console.warn('Load vue/package.json failed from', folder);
+    }
+}
+function resolvePath(scriptPath, root) {
+    try {
+        if (require?.resolve) {
+            return require.resolve(scriptPath, { paths: [root] });
         }
-        catch (error) {
-            // console.warn(error);
+        else {
+            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
         }
     }
+    catch (error) {
+        // console.warn(error);
+    }
 }
-function getDefaultOptions(options) {
-    const target = options.target ?? 3.3;
-    const lib = options.lib ?? 'vue';
+function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
     return {
         target,
         lib,
@@ -178,7 +213,10 @@ function getDefaultOptions(options) {
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
-        strictTemplates: false,
+        checkUnknownProps: strictTemplates,
+        checkUnknownEvents: strictTemplates,
+        checkUnknownDirectives: strictTemplates,
+        checkUnknownComponents: strictTemplates,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
         dataAttributes: [],
@@ -204,25 +242,7 @@ function getDefaultOptions(options) {
         plugins: [],
         experimentalDefinePropProposal: false,
         experimentalResolveStyleCssClasses: 'scoped',
-        experimentalModelPropName: null
-    };
-}
-;
-function resolveVueCompilerOptions(options, defaults = getDefaultOptions(options)) {
-    return {
-        ...defaults,
-        ...options,
-        macros: {
-            ...defaults.macros,
-            ...options.macros,
-        },
-        composables: {
-            ...defaults.composables,
-            ...options.composables,
-        },
-        // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
-        // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
-        experimentalModelPropName: Object.fromEntries(Object.entries(options.experimentalModelPropName ?? defaults.experimentalModelPropName ?? {
+        experimentalModelPropName: {
             '': {
                 input: true
             },
@@ -231,7 +251,16 @@ function resolveVueCompilerOptions(options, defaults = getDefaultOptions(options
                 textarea: true,
                 select: true
             }
-        }).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
+        },
+    };
+}
+/**
+ * @deprecated use `getDefaultCompilerOptions` instead
+ */
+function resolveVueCompilerOptions(options) {
+    return {
+        ...getDefaultCompilerOptions(options.target, options.lib),
+        ...options,
     };
 }
 function setupGlobalTypes(rootDir, vueOptions, host) {
@@ -247,8 +276,8 @@ function setupGlobalTypes(rootDir, vueOptions, host) {
             }
             dir = parentDir;
         }
-        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', `${vueOptions.lib}_${vueOptions.target}_${vueOptions.strictTemplates}.d.ts`);
-        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions.lib, vueOptions.target, vueOptions.strictTemplates);
+        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(vueOptions));
+        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions);
         host.writeFile(globalTypesPath, globalTypesContents);
         return { absolutePath: globalTypesPath };
     }

package/lib/virtualFile/computedEmbeddedCodes.d.ts

@@ -1,4 +1,4 @@
 import type { VirtualCode } from '@volar/language-core';
 import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): import("alien-signals").Computed<VirtualCode[]>;
+export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
 export declare function resolveCommonLanguageId(lang: string): string;

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -7,7 +7,7 @@ const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const embeddedFile_1 = require("./embeddedFile");
 function computedEmbeddedCodes(plugins, fileName, sfc) {
-    const nameToBlock = (0, alien_signals_1.computed)(() => {
+    const getNameToBlockMap = (0, alien_signals_1.computed)(() => {
         const blocks = {};
         if (sfc.template) {
             blocks[sfc.template.name] = sfc.template;
@@ -26,11 +26,11 @@ function computedEmbeddedCodes(plugins, fileName, sfc) {
         }
         return blocks;
     });
-    const pluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock));
-    const flatResult = (0, alien_signals_1.computed)(() => pluginsResult.map(r => r.get()).flat());
-    const structuredResult = (0, alien_signals_1.computed)(() => {
+    const getPluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, name => getNameToBlockMap()[name]));
+    const getFlatResult = (0, alien_signals_1.computed)(() => getPluginsResult.map(r => r()).flat());
+    const getStructuredResult = (0, alien_signals_1.computed)(() => {
         const embeddedCodes = [];
-        let remain = [...flatResult.get()];
+        let remain = [...getFlatResult()];
         while (remain.length) {
             const beforeLength = remain.length;
             consumeRemain();
@@ -85,12 +85,12 @@ function computedEmbeddedCodes(plugins, fileName, sfc) {
             }
         }
     });
-    return structuredResult;
+    return getStructuredResult;
 }
-function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock) {
+function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByName) {
     const computeds = new Map();
     const getComputedKey = (code) => code.id + '__' + code.lang;
-    const codes = (0, alien_signals_1.computed)(() => {
+    const getCodes = (0, alien_signals_1.computed)(() => {
         try {
             if (!plugin.getEmbeddedCodes) {
                 return [...computeds.values()];
@@ -148,8 +148,8 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
         return [...computeds.values()];
     });
     return (0, alien_signals_1.computed)(() => {
-        return codes.get().map(_file => {
-            const { code, snapshot } = _file.get();
+        return getCodes().map(_file => {
+            const { code, snapshot } = _file();
             const mappings = (0, buildMappings_1.buildMappings)(code.content.map(segment => {
                 if (typeof segment === 'string') {
                     return segment;
@@ -158,7 +158,7 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
                 if (source === undefined) {
                     return segment;
                 }
-                const block = nameToBlock.get()[source];
+                const block = getBlockByName(source);
                 if (!block) {
                     // console.warn('Unable to find block: ' + source);
                     return segment;

package/lib/virtualFile/computedSfc.d.ts

@@ -1,5 +1,4 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
-import { ISignal, Signal } from 'alien-signals';
 import type * as ts from 'typescript';
 import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, snapshot: Signal<ts.IScriptSnapshot>, parsed: ISignal<SFCParseResult | undefined>): Sfc;
+export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, getSnapshot: () => ts.IScriptSnapshot, getParseResult: () => SFCParseResult | undefined): Sfc;

package/lib/virtualFile/computedSfc.js

@@ -4,39 +4,38 @@ exports.computedSfc = computedSfc;
 const alien_signals_1 = require("alien-signals");
 const parseCssClassNames_1 = require("../utils/parseCssClassNames");
 const parseCssVars_1 = require("../utils/parseCssVars");
-function computedSfc(ts, plugins, fileName, snapshot, parsed) {
-    const untrackedSnapshot = () => {
-        const prevSub = alien_signals_1.activeSub;
-        const prevTrackId = alien_signals_1.activeTrackId;
-        (0, alien_signals_1.setActiveSub)(undefined, 0);
-        const res = snapshot.get();
-        (0, alien_signals_1.setActiveSub)(prevSub, prevTrackId);
+const signals_1 = require("../utils/signals");
+function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
+    const getUntrackedSnapshot = () => {
+        (0, alien_signals_1.pauseTracking)();
+        const res = getSnapshot();
+        (0, alien_signals_1.resumeTracking)();
         return res;
     };
-    const content = (0, alien_signals_1.computed)(() => {
-        return snapshot.get().getText(0, snapshot.get().getLength());
+    const getContent = (0, alien_signals_1.computed)(() => {
+        return getSnapshot().getText(0, getSnapshot().getLength());
     });
-    const comments = (0, alien_signals_1.computed)(oldValue => {
-        const newValue = parsed.get()?.descriptor.comments ?? [];
+    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])) {
+            && oldValue?.every((v, i) => v === newValue[i])) {
             return oldValue;
         }
         return newValue;
     });
-    const template = computedNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => parsed.get()?.descriptor.template ?? undefined), (_block, base) => {
+    const getTemplate = computedNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.template ?? undefined), (_block, base) => {
         const compiledAst = computedTemplateAst(base);
         return mergeObject(base, {
-            get ast() { return compiledAst.get()?.ast; },
-            get errors() { return compiledAst.get()?.errors; },
-            get warnings() { return compiledAst.get()?.warnings; },
+            get ast() { return compiledAst()?.ast; },
+            get errors() { return compiledAst()?.errors; },
+            get warnings() { return compiledAst()?.warnings; },
         });
     });
-    const script = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => parsed.get()?.descriptor.script ?? undefined), (block, base) => {
-        const src = (0, alien_signals_1.computed)(() => block.get().src);
+    const getScript = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.script ?? undefined), (block, base) => {
+        const src = (0, alien_signals_1.computed)(() => block().src);
         const srcOffset = (0, alien_signals_1.computed)(() => {
-            const _src = src.get();
-            return _src ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_src) - base.startTagEnd : -1;
+            const _src = src();
+            return _src ? getUntrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_src) - base.startTagEnd : -1;
         });
         const ast = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
@@ -48,19 +47,19 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
             return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
         });
         return mergeObject(base, {
-            get src() { return src.get(); },
-            get srcOffset() { return srcOffset.get(); },
-            get ast() { return ast.get(); },
+            get src() { return src(); },
+            get srcOffset() { return srcOffset(); },
+            get ast() { return ast(); },
         });
     });
-    const scriptSetupOriginal = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => parsed.get()?.descriptor.scriptSetup ?? undefined), (block, base) => {
+    const getOriginalScriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
         const generic = (0, alien_signals_1.computed)(() => {
-            const _block = block.get();
+            const _block = block();
             return typeof _block.attrs.generic === 'string' ? _block.attrs.generic : undefined;
         });
         const genericOffset = (0, alien_signals_1.computed)(() => {
-            const _generic = generic.get();
-            return _generic !== undefined ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_generic) - base.startTagEnd : -1;
+            const _generic = generic();
+            return _generic !== undefined ? getUntrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_generic) - base.startTagEnd : -1;
         });
         const ast = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
@@ -72,15 +71,15 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
             return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
         });
         return mergeObject(base, {
-            get generic() { return generic.get(); },
-            get genericOffset() { return genericOffset.get(); },
-            get ast() { return ast.get(); },
+            get generic() { return generic(); },
+            get genericOffset() { return genericOffset(); },
+            get ast() { return ast(); },
         });
     });
-    const hasScript = (0, alien_signals_1.computed)(() => !!parsed.get()?.descriptor.script);
-    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!parsed.get()?.descriptor.scriptSetup);
-    const scriptSetup = (0, alien_signals_1.computed)(() => {
-        if (!hasScript.get() && !hasScriptSetup.get()) {
+    const hasScript = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.script);
+    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.scriptSetup);
+    const getScriptSetup = (0, alien_signals_1.computed)(() => {
+        if (!hasScript() && !hasScriptSetup()) {
             //#region monkey fix: https://github.com/vuejs/language-tools/pull/2113
             return {
                 content: '',
@@ -96,40 +95,40 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
                 ast: ts.createSourceFile('', '', 99, false, ts.ScriptKind.TS),
             };
         }
-        return scriptSetupOriginal.get();
+        return getOriginalScriptSetup();
     });
-    const styles = alien_signals_1.unstable.computedArray((0, alien_signals_1.computed)(() => parsed.get()?.descriptor.styles ?? []), (block, i) => {
-        const base = computedSfcBlock('style_' + i, 'css', block);
-        const module = (0, alien_signals_1.computed)(() => {
-            const { __module } = block.get();
+    const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
+        const base = computedSfcBlock('style_' + i, 'css', getBlock);
+        const getModule = (0, alien_signals_1.computed)(() => {
+            const { __module } = getBlock();
             return __module ? {
                 name: __module.name,
                 offset: __module.offset ? base.start + __module.offset : undefined
             } : undefined;
         });
-        const scoped = (0, alien_signals_1.computed)(() => !!block.get().scoped);
-        const cssVars = (0, alien_signals_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
-        const classNames = (0, alien_signals_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
+        const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
+        const getCssVars = (0, alien_signals_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
+        const getClassNames = (0, alien_signals_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
         return () => mergeObject(base, {
-            get module() { return module.get(); },
-            get scoped() { return scoped.get(); },
-            get cssVars() { return cssVars.get(); },
-            get classNames() { return classNames.get(); },
+            get module() { return getModule(); },
+            get scoped() { return getScoped(); },
+            get cssVars() { return getCssVars(); },
+            get classNames() { return getClassNames(); },
         });
     });
-    const customBlocks = alien_signals_1.unstable.computedArray((0, alien_signals_1.computed)(() => parsed.get()?.descriptor.customBlocks ?? []), (block, i) => {
-        const base = computedSfcBlock('custom_block_' + i, 'txt', block);
-        const type = (0, alien_signals_1.computed)(() => block.get().type);
+    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 getType = (0, alien_signals_1.computed)(() => getBlock().type);
         return () => mergeObject(base, {
-            get type() { return type.get(); },
+            get type() { return getType(); },
         });
     });
     return {
-        get content() { return content.get(); },
-        get comments() { return comments.get(); },
-        get template() { return template.get(); },
-        get script() { return script.get(); },
-        get scriptSetup() { return scriptSetup.get(); },
+        get content() { return getContent(); },
+        get comments() { return getComments(); },
+        get template() { return getTemplate(); },
+        get script() { return getScript(); },
+        get scriptSetup() { return getScriptSetup(); },
         get styles() { return styles; },
         get customBlocks() { return customBlocks; },
     };
@@ -145,14 +144,12 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
             }
             // incremental update
             if (cache?.plugin.updateSFCTemplate) {
-                const change = untrackedSnapshot().getChangeRange(cache.snapshot);
+                const change = getUntrackedSnapshot().getChangeRange(cache.snapshot);
                 if (change) {
-                    const prevSub = alien_signals_1.activeSub;
-                    const prevTrackId = alien_signals_1.activeTrackId;
-                    (0, alien_signals_1.setActiveSub)(undefined, 0);
+                    (0, alien_signals_1.pauseTracking)();
                     const templateOffset = base.startTagEnd;
-                    (0, alien_signals_1.setActiveSub)(prevSub, prevTrackId);
-                    const newText = untrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
+                    (0, alien_signals_1.resumeTracking)();
+                    const newText = getUntrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
                     const newResult = cache.plugin.updateSFCTemplate(cache.result, {
                         start: change.span.start - templateOffset,
                         end: change.span.start + change.span.length - templateOffset,
@@ -160,7 +157,7 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
                     });
                     if (newResult) {
                         cache.template = base.content;
-                        cache.snapshot = untrackedSnapshot();
+                        cache.snapshot = getUntrackedSnapshot();
                         cache.result = newResult;
                         return {
                             errors: [],
@@ -195,7 +192,7 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
                     if (result && !errors.length && !warnings.length) {
                         cache = {
                             template: base.content,
-                            snapshot: untrackedSnapshot(),
+                            snapshot: getUntrackedSnapshot(),
                             result: result,
                             plugin,
                         };
@@ -217,33 +214,33 @@ function computedSfc(ts, plugins, fileName, snapshot, parsed) {
             };
         });
     }
-    function computedNullableSfcBlock(name, defaultLang, block, resolve) {
-        const hasBlock = (0, alien_signals_1.computed)(() => !!block.get());
+    function computedNullableSfcBlock(name, defaultLang, getBlock, resolve) {
+        const hasBlock = (0, alien_signals_1.computed)(() => !!getBlock());
         return (0, alien_signals_1.computed)(() => {
-            if (!hasBlock.get()) {
+            if (!hasBlock()) {
                 return;
             }
-            const _block = (0, alien_signals_1.computed)(() => block.get());
+            const _block = (0, alien_signals_1.computed)(() => getBlock());
             return resolve(_block, computedSfcBlock(name, defaultLang, _block));
         });
     }
-    function computedSfcBlock(name, defaultLang, block) {
-        const lang = (0, alien_signals_1.computed)(() => block.get().lang ?? defaultLang);
-        const attrs = (0, alien_signals_1.computed)(() => block.get().attrs); // TODO: computed it
-        const content = (0, alien_signals_1.computed)(() => block.get().content);
-        const startTagEnd = (0, alien_signals_1.computed)(() => block.get().loc.start.offset);
-        const endTagStart = (0, alien_signals_1.computed)(() => block.get().loc.end.offset);
-        const start = (0, alien_signals_1.computed)(() => untrackedSnapshot().getText(0, startTagEnd.get()).lastIndexOf('<' + block.get().type));
-        const end = (0, alien_signals_1.computed)(() => endTagStart.get() + untrackedSnapshot().getText(endTagStart.get(), untrackedSnapshot().getLength()).indexOf('>') + 1);
+    function computedSfcBlock(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);
+        const getStartTagEnd = (0, alien_signals_1.computed)(() => getBlock().loc.start.offset);
+        const getEndTagStart = (0, alien_signals_1.computed)(() => getBlock().loc.end.offset);
+        const getStart = (0, alien_signals_1.computed)(() => getUntrackedSnapshot().getText(0, getStartTagEnd()).lastIndexOf('<' + getBlock().type));
+        const getEnd = (0, alien_signals_1.computed)(() => getEndTagStart() + getUntrackedSnapshot().getText(getEndTagStart(), getUntrackedSnapshot().getLength()).indexOf('>') + 1);
         return {
             name,
-            get lang() { return lang.get(); },
-            get attrs() { return attrs.get(); },
-            get content() { return content.get(); },
-            get startTagEnd() { return startTagEnd.get(); },
-            get endTagStart() { return endTagStart.get(); },
-            get start() { return start.get(); },
-            get end() { return end.get(); },
+            get lang() { return getLang(); },
+            get attrs() { return getAttrs(); },
+            get content() { return getContent(); },
+            get startTagEnd() { return getStartTagEnd(); },
+            get endTagStart() { return getEndTagStart(); },
+            get start() { return getStart(); },
+            get end() { return getEnd(); },
         };
     }
 }

package/lib/virtualFile/computedVueSfc.d.ts

@@ -1,5 +1,4 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
-import { Signal } from 'alien-signals';
 import type * as ts from 'typescript';
 import type { VueLanguagePluginReturn } from '../types';
-export declare function computedVueSfc(plugins: VueLanguagePluginReturn[], fileName: string, languageId: string, snapshot: Signal<ts.IScriptSnapshot>): import("alien-signals").Computed<SFCParseResult | undefined>;
+export declare function computedVueSfc(plugins: VueLanguagePluginReturn[], fileName: string, languageId: string, getSnapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;