@vue/language-core 2.0.26-alpha.2 → 2.0.28

package/lib/languagePlugin.js

@@ -0,0 +1,175 @@
+"use strict";
+/// <reference types="@volar/typescript" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRootFileChecker = createRootFileChecker;
+exports.createVueLanguagePlugin = createVueLanguagePlugin;
+exports.createVueLanguagePlugin2 = createVueLanguagePlugin2;
+exports.getAllExtensions = getAllExtensions;
+const language_core_1 = require("@volar/language-core");
+const CompilerDOM = require("@vue/compiler-dom");
+const plugins_1 = require("./plugins");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const vueFile_1 = require("./virtualFile/vueFile");
+const normalFileRegistries = [];
+const holderFileRegistries = [];
+function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {
+    const fileRegistries = isGlobalTypesHolder ? holderFileRegistries : normalFileRegistries;
+    let fileRegistry = fileRegistries.find(r => r.key === key
+        && r.plugins.length === plugins.length
+        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
+    if (!fileRegistry) {
+        fileRegistry = new Map();
+        fileRegistries.push({
+            key: key,
+            plugins: plugins,
+            files: fileRegistry,
+        });
+    }
+    return fileRegistry;
+}
+function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
+    const values = [
+        ...Object.keys(vueCompilerOptions)
+            .sort()
+            .filter(key => key !== 'plugins')
+            .map(key => [key, vueCompilerOptions[key]]),
+        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+            .sort()
+            .map(key => [key, compilerOptions[key]]),
+    ];
+    return JSON.stringify(values);
+}
+function createRootFileChecker(getProjectVersion, getRootFileNames, caseSensitive) {
+    const fileNames = new language_core_1.FileMap(caseSensitive);
+    let projectVersion;
+    return (fileName) => {
+        if (!getProjectVersion || projectVersion !== getProjectVersion()) {
+            projectVersion = getProjectVersion?.();
+            fileNames.clear();
+            for (const rootFileName of getRootFileNames()) {
+                fileNames.set(rootFileName, undefined);
+            }
+        }
+        return fileNames.has(fileName);
+    };
+}
+// TODO: replace `createVueLanguagePlugin` with `createVueLanguagePlugin2` in 2.1
+function createVueLanguagePlugin(ts, asFileName, _getProjectVersion, isRootFile, compilerOptions, vueCompilerOptions) {
+    return createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions);
+}
+function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions) {
+    const pluginContext = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+        globalTypesHolder: undefined,
+    };
+    const plugins = (0, plugins_1.createPlugins)(pluginContext);
+    return {
+        getLanguageId(scriptId) {
+            const fileName = asFileName(scriptId);
+            for (const plugin of plugins) {
+                const languageId = plugin.getLanguageId?.(fileName);
+                if (languageId) {
+                    return languageId;
+                }
+            }
+        },
+        createVirtualCode(scriptId, languageId, snapshot) {
+            const fileName = asFileName(scriptId);
+            if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
+                if (!pluginContext.globalTypesHolder && isRootFile(fileName)) {
+                    pluginContext.globalTypesHolder = fileName;
+                }
+                const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
+                const code = fileRegistry.get(fileName);
+                if (code) {
+                    code.update(snapshot);
+                    return code;
+                }
+                else {
+                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    fileRegistry.set(fileName, code);
+                    return code;
+                }
+            }
+        },
+        updateVirtualCode(_fileId, code, snapshot) {
+            code.update(snapshot);
+            return code;
+        },
+        // TODO: when global types holder deleted, move global types to another file
+        // disposeVirtualCode(fileId, code) {
+        // 	const isGlobalTypesHolder = code.fileName === pluginContext.globalTypesHolder;
+        // 	const fileRegistry = getFileRegistry(isGlobalTypesHolder);
+        // 	fileRegistry.delete(fileId);
+        // 	if (isGlobalTypesHolder) {
+        // 		pluginContext.globalTypesHolder = undefined;
+        // 		const fileRegistry2 = getFileRegistry(false);
+        // 		for (const [fileId, code] of fileRegistry2) {
+        // 			if (isValidGlobalTypesHolder(code.fileName)) {
+        // 				pluginContext.globalTypesHolder = code.fileName;
+        // 				fileRegistry2.delete(fileId);
+        // 				// force dirty
+        // 				files?.delete(fileId);
+        // 				files?.set(
+        // 					fileId,
+        // 					code.languageId,
+        // 					code.snapshot,
+        // 				);
+        // 				break;
+        // 			}
+        // 		}
+        // 	}
+        // },
+        typescript: {
+            extraFileExtensions: getAllExtensions(vueCompilerOptions)
+                .map(ext => ({
+                extension: ext.slice(1),
+                isMixedContent: true,
+                scriptKind: 7,
+            })),
+            getServiceScript(root) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
+                    if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
+                        const lang = code.id.substring('script_'.length);
+                        return {
+                            code,
+                            extension: '.' + lang,
+                            scriptKind: lang === 'js' ? ts.ScriptKind.JS
+                                : lang === 'jsx' ? ts.ScriptKind.JSX
+                                    : lang === 'tsx' ? ts.ScriptKind.TSX
+                                        : ts.ScriptKind.TS,
+                        };
+                    }
+                }
+            },
+        },
+    };
+    function getFileRegistry(isGlobalTypesHolder) {
+        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    }
+}
+function getAllExtensions(options) {
+    const result = new Set();
+    for (const key in options) {
+        if (key === 'extensions' || key.endsWith('Extensions')) {
+            const value = options[key];
+            if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
+                for (const ext of value) {
+                    result.add(ext);
+                }
+            }
+        }
+    }
+    return [...result];
+}
+//# sourceMappingURL=languagePlugin.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -32,7 +32,9 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
             arg?: TextRange;
             typeArg?: TextRange;
-        }>;
+        }> & {
+            hasUnionTypeArg?: boolean;
+        };
     };
     expose: {
         name?: string;

package/lib/parsers/scriptSetupRanges.js

@@ -168,6 +168,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 if (ts.isVariableDeclaration(parent)) {
                     emits.name = getNodeText(ts, parent.name, ast);
                 }
+                if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0]) && node.typeArguments[0].members.at(0)) {
+                    for (const member of node.typeArguments[0].members) {
+                        if (ts.isCallSignatureDeclaration(member) && member.parameters[0].type && ts.isUnionTypeNode(member.parameters[0].type)) {
+                            emits.define.hasUnionTypeArg = true;
+                            return;
+                        }
+                    }
+                }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
                 expose.define = parseDefineFunction(node);

package/lib/plugins/file-dot-setup.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-dot-setup.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const jsxWrapper = ['<script setup lang="jsx">\n', '\n</script>'];
+const tsxWrapper = ['<script setup lang="tsx">\n', '\n</script>'];
+const plugin = _ctx => {
+    return {
+        version: 2.1,
+        isValidFile(fileName) {
+            return fileName.endsWith('.setup.jsx') || fileName.endsWith('.setup.tsx');
+        },
+        parseSFC2(fileName, _languageId, content) {
+            if (fileName.endsWith('.setup.jsx')) {
+                console.log('[Vue] parseSFC2', fileName);
+                return patchSFC((0, parseSfc_1.parse)(`${jsxWrapper[0]}${content}${jsxWrapper[1]}`));
+            }
+            if (fileName.endsWith('.setup.tsx')) {
+                console.log('[Vue] parseSFC2', fileName);
+                return patchSFC((0, parseSfc_1.parse)(`${tsxWrapper[0]}${content}${tsxWrapper[1]}`));
+            }
+        },
+    };
+};
+exports.default = plugin;
+function patchSFC(sfc) {
+    sfc.descriptor.scriptSetup.loc.start.column -= jsxWrapper[0].length;
+    sfc.descriptor.scriptSetup.loc.start.offset -= jsxWrapper[0].length;
+    sfc.descriptor.scriptSetup.loc.end.offset -= jsxWrapper[0].length;
+    if (sfc.descriptor.scriptSetup.loc.end.line === sfc.descriptor.scriptSetup.loc.start.line) {
+        sfc.descriptor.scriptSetup.loc.end.column -= jsxWrapper[0].length;
+    }
+    return sfc;
+}
+//# sourceMappingURL=file-dot-setup.js.map

package/lib/plugins/file-html.js

@@ -2,10 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
 const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
-const plugin = () => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.petiteVueExtensions.some(ext => fileName.endsWith(ext))) {
+                return 'html';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'html';
+        },
+        parseSFC2(fileName, languageId, content) {
+            if (languageId !== 'html') {
+                return;
+            }
             let sfc = {
                 descriptor: {
                     filename: fileName,

package/lib/plugins/file-md.js

@@ -11,10 +11,21 @@ const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
 const angleBracketReg = /\<\S*\:\S*\>/g;
 const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
-const plugin = () => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(_fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.vitePressExtensions.some(ext => fileName.endsWith(ext))) {
+                return 'markdown';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'markdown';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'markdown') {
+                return;
+            }
             content = content
                 // code block
                 .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)

package/lib/plugins/file-vue.js

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const parseSfc_1 = require("../utils/parseSfc");
-const plugin = _ctx => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(_fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
             return (0, parseSfc_1.parse)(content);
         },
         updateSFC(sfc, change) {

package/lib/plugins/vue-script-js.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 2,
+        version: 2.1,
         compileSFCScript(lang, script) {
             if (lang === 'js' || lang === 'ts' || lang === 'jsx' || lang === 'tsx') {
                 const ts = modules.typescript;

package/lib/plugins/vue-sfc-customblocks.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             return sfc.customBlocks.map((customBlock, i) => ({
                 id: 'custom_block_' + i,

package/lib/plugins/vue-sfc-scripts.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             const names = [];
             if (sfc.script) {

package/lib/plugins/vue-sfc-styles.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             const result = [];
             for (let i = 0; i < sfc.styles.length; i++) {

package/lib/plugins/vue-sfc-template.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (sfc.template) {
                 return [{

package/lib/plugins/vue-template-html.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 2,
+        version: 2.1,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
                 const compiler = modules['@vue/compiler-dom'];

package/lib/plugins/vue-template-inline-css.js

@@ -10,7 +10,7 @@ const codeFeatures = {
 };
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

package/lib/plugins/vue-template-inline-ts.js

@@ -22,7 +22,7 @@ const formatBrackets = {
 const plugin = ctx => {
     const parseds = new WeakMap();
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

package/lib/plugins/vue-tsx.d.ts

@@ -43,7 +43,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
-            }>;
+            }> & {
+                hasUnionTypeArg?: boolean;
+            };
         };
         expose: {
             name?: string;

package/lib/plugins/vue-tsx.js

@@ -10,7 +10,7 @@ const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
 const plugin = ctx => {
     return {
-        version: 2,
+        version: 2.1,
         requiredCompilerOptions: [
             'noPropertyAccessFromIndexSignature',
             'exactOptionalPropertyTypes',

package/lib/plugins.d.ts

@@ -1,27 +1,3 @@
-import { pluginVersion, type VueLanguagePlugin } from './types';
+import { VueLanguagePlugin } from './types';
 export * from './plugins/shared';
-export declare function getBasePlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): {
-    version: typeof pluginVersion;
-    name?: string;
-    order?: number;
-    requiredCompilerOptions?: string[];
-    parseSFC?(fileName: string, content: string): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    updateSFC?(oldResult: import("@vue/compiler-sfc").SFCParseResult, textChange: {
-        start: number;
-        end: number;
-        newText: string;
-    }): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    resolveTemplateCompilerOptions?(options: import("@vue/compiler-dom").CompilerOptions): import("@vue/compiler-dom").CompilerOptions;
-    compileSFCScript?(lang: string, script: string): import("typescript").SourceFile | undefined;
-    compileSFCTemplate?(lang: string, template: string, options: import("@vue/compiler-dom").CompilerOptions): import("@vue/compiler-dom").CodegenResult | undefined;
-    updateSFCTemplate?(oldResult: import("@vue/compiler-dom").CodegenResult, textChange: {
-        start: number;
-        end: number;
-        newText: string;
-    }): import("@vue/compiler-dom").CodegenResult | undefined;
-    getEmbeddedCodes?(fileName: string, sfc: import("./types").Sfc): {
-        id: string;
-        lang: string;
-    }[];
-    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./types").VueEmbeddedCode): void;
-}[];
+export declare function createPlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): import("./types").VueLanguagePluginReturn[];

package/lib/plugins.js

@@ -14,20 +14,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBasePlugins = getBasePlugins;
+exports.createPlugins = createPlugins;
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
+const vue_script_js_1 = require("./plugins/vue-script-js");
 const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
 const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
 const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
 const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
-const vue_script_js_1 = require("./plugins/vue-script-js");
 const vue_template_html_1 = require("./plugins/vue-template-html");
 const vue_template_inline_css_1 = require("./plugins/vue-template-inline-css");
 const vue_template_inline_ts_1 = require("./plugins/vue-template-inline-ts");
 const vue_tsx_1 = require("./plugins/vue-tsx");
 const types_1 = require("./types");
 __exportStar(require("./plugins/shared"), exports);
-function getBasePlugins(pluginContext) {
+function createPlugins(pluginContext) {
     const plugins = [
+        file_vue_1.default,
+        file_md_1.default,
+        file_html_1.default,
         vue_script_js_1.default,
         vue_template_html_1.default,
         vue_template_inline_css_1.default,
@@ -40,28 +46,36 @@ function getBasePlugins(pluginContext) {
         ...pluginContext.vueCompilerOptions.plugins,
     ];
     const pluginInstances = plugins
-        .map(plugin => {
+        .flatMap(plugin => {
         try {
             const instance = plugin(pluginContext);
-            instance.name ??= plugin.__moduleName;
+            const moduleName = plugin.__moduleName;
+            if (Array.isArray(instance)) {
+                for (let i = 0; i < instance.length; i++) {
+                    instance[i].name ??= `${moduleName} (${i})`;
+                }
+            }
+            else {
+                instance.name ??= moduleName;
+            }
             return instance;
         }
         catch (err) {
             console.warn('[Vue] Failed to create plugin', err);
         }
     })
-        .filter((plugin) => !!plugin)
+        .filter(plugin => !!plugin)
         .sort((a, b) => {
         const aOrder = a.order ?? 0;
         const bOrder = b.order ?? 0;
         return aOrder - bOrder;
     });
     return pluginInstances.filter(plugin => {
-        const valid = plugin.version === types_1.pluginVersion;
-        if (!valid) {
-            console.warn(`[Vue] Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected "${types_1.pluginVersion}" but got "${plugin.version}".`);
+        if (!types_1.validVersions.includes(plugin.version)) {
+            console.warn(`[Vue] Plugin ${plugin.name} is not compatible with the current Vue language tools version. (version: ${plugin.version}, supported versions: ${JSON.stringify(types_1.validVersions)})`);
+            return false;
         }
-        return valid;
+        return true;
     });
 }
 //# sourceMappingURL=plugins.js.map

package/lib/types.d.ts

@@ -48,21 +48,16 @@ export interface VueCompilerOptions {
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
 }
-export declare const pluginVersion = 2;
-export type VueLanguagePlugin = (ctx: {
-    modules: {
-        typescript: typeof import('typescript');
-        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
-    };
-    compilerOptions: ts.CompilerOptions;
-    vueCompilerOptions: VueCompilerOptions;
-    globalTypesHolder: string | undefined;
-}) => {
-    version: typeof pluginVersion;
+export declare const validVersions: readonly [2, 2.1];
+export type VueLanguagePluginReturn = {
+    version: typeof validVersions[number];
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];
+    getLanguageId?(fileName: string): string | undefined;
+    isValidFile?(fileName: string, languageId: string): boolean;
     parseSFC?(fileName: string, content: string): SFCParseResult | undefined;
+    parseSFC2?(fileName: string, languageId: string, content: string): SFCParseResult | undefined;
     updateSFC?(oldResult: SFCParseResult, textChange: {
         start: number;
         end: number;
@@ -82,6 +77,15 @@ export type VueLanguagePlugin = (ctx: {
     }[];
     resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
 };
+export type VueLanguagePlugin = (ctx: {
+    modules: {
+        typescript: typeof import('typescript');
+        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    globalTypesHolder: string | undefined;
+}) => VueLanguagePluginReturn | VueLanguagePluginReturn[];
 export interface SfcBlock {
     name: string;
     start: number;

package/lib/types.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginVersion = void 0;
-exports.pluginVersion = 2;
+exports.validVersions = void 0;
+exports.validVersions = [2, 2.1];
 //# sourceMappingURL=types.js.map

package/lib/utils/ts.js

@@ -4,6 +4,7 @@ exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
 const path = require("path-browserify");
+const languagePlugin_1 = require("../languagePlugin");
 function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
@@ -18,11 +19,8 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         catch (err) { }
     }
     const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, [
-        ...resolvedVueOptions.extensions,
-        ...resolvedVueOptions.vitePressExtensions,
-        ...resolvedVueOptions.petiteVueExtensions,
-    ].map(extension => ({
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
+        .map(extension => ({
         extension: extension.slice(1),
         isMixedContent: true,
         scriptKind: ts.ScriptKind.Deferred,
@@ -52,11 +50,8 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
             catch (err) { }
         }
         const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, [
-            ...resolvedVueOptions.extensions,
-            ...resolvedVueOptions.vitePressExtensions,
-            ...resolvedVueOptions.petiteVueExtensions,
-        ].map(extension => ({
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
+            .map(extension => ({
             extension: extension.slice(1),
             isMixedContent: true,
             scriptKind: ts.ScriptKind.Deferred,
@@ -129,14 +124,7 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
                 const resolvedPath = resolvePath(pluginPath);
                 if (resolvedPath) {
                     const plugin = require(resolvedPath);
-                    if (Array.isArray(plugin)) {
-                        for (let i = 0; i < plugin.length; i++) {
-                            plugin[i].__moduleName = `${pluginPath} (${i})`;
-                        }
-                    }
-                    else {
-                        plugin.__moduleName = pluginPath;
-                    }
+                    plugin.__moduleName = pluginPath;
                     return plugin;
                 }
                 else {
@@ -147,8 +135,7 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
                 console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
             }
             return [];
-        })
-            .flat(Infinity);
+        });
         result.plugins = plugins;
     }
     return result;

package/lib/virtualFile/computedFiles.d.ts

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