@vue/language-core 2.0.7 → 2.0.10

package/lib/generators/template.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.eachElementNode = exports.generate = void 0;
+exports.forEachElementNode = exports.parseVForNode = exports.parseInterpolationNode = exports.isCompoundExpression = exports.createTsAst = exports.generate = void 0;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
@@ -36,15 +36,6 @@ const presetInfos = {
     slotNameExport: (0, utils_1.disableAllFeatures)({ semantic: { shouldHighlight: () => false }, verification: true, navigation: true, /* __navigationCodeLens: true */ }),
     refAttr: (0, utils_1.disableAllFeatures)({ navigation: true }),
 };
-const formatBrackets = {
-    normal: ['`${', '}`;'],
-    // fix https://github.com/vuejs/language-tools/issues/3572
-    params: ['(', ') => {}'],
-    // fix https://github.com/vuejs/language-tools/issues/1210
-    // fix https://github.com/vuejs/language-tools/issues/2305
-    curly: ['0 +', '+ 0;'],
-    event: ['() => ', ';'],
-};
 const validTsVarReg = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 const colonReg = /:/g;
 // @ts-ignore
@@ -64,41 +55,39 @@ const transformContext = {
 };
 function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGenerateScopedClasses, stylesScopedClasses, hasScriptSetupSlots, slotsAssignName, propsAssignName, codegenStack) {
     const processDirectiveComment = (code) => {
-        if (ignoreError && typeof code !== 'string') {
-            const data = code[3];
-            if (data.verification) {
-                code[3] = {
-                    ...data,
-                    verification: false,
-                };
+        if (typeof code !== 'string') {
+            if (ignoreError) {
+                const data = code[3];
+                if (data.verification) {
+                    code[3] = {
+                        ...data,
+                        verification: false,
+                    };
+                }
             }
-        }
-        if (expectErrorToken && typeof code !== 'string') {
-            const token = expectErrorToken;
-            const data = code[3];
-            if (data.verification) {
-                code[3] = {
-                    ...data,
-                    verification: {
-                        shouldReport: () => {
-                            token.errors++;
-                            return false;
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                const data = code[3];
+                if (data.verification) {
+                    code[3] = {
+                        ...data,
+                        verification: {
+                            shouldReport: () => {
+                                token.errors++;
+                                return false;
+                            },
                         },
-                    },
-                };
+                    };
+                }
             }
+            code[3].structure = false;
+            code[3].format = false;
         }
         return code;
     };
     const _ts = codegenStack
-        ? (code) => ['ts', processDirectiveComment(code), (0, utils_1.getStack)()]
-        : (code) => ['ts', processDirectiveComment(code), ''];
-    const _tsFormat = codegenStack
-        ? (code) => ['tsFormat', code, (0, utils_1.getStack)()]
-        : (code) => ['tsFormat', code, ''];
-    const _inlineCss = codegenStack
-        ? (code) => ['inlineCss', code, (0, utils_1.getStack)()]
-        : (code) => ['inlineCss', code, ''];
+        ? (code) => [processDirectiveComment(code), (0, utils_1.getStack)()]
+        : (code) => [processDirectiveComment(code), ''];
     const nativeTags = new Set(vueCompilerOptions.nativeTags);
     const slots = new Map();
     const slotExps = new Map();
@@ -142,7 +131,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         if (!template.ast) {
             return tagOffsetsMap;
         }
-        for (const node of eachElementNode(template.ast)) {
+        for (const node of forEachElementNode(template.ast)) {
             if (node.tag === 'slot') {
                 // ignore
             }
@@ -352,24 +341,8 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
         else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
             // {{ ... }}
-            let content = node.content.loc.source;
-            let start = node.content.loc.start.offset;
-            let leftCharacter;
-            let rightCharacter;
-            // fix https://github.com/vuejs/language-tools/issues/1787
-            while ((leftCharacter = template.content.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
-                start--;
-                content = leftCharacter + content;
-            }
-            while ((rightCharacter = template.content.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
-                content = content + rightCharacter;
-            }
+            const [content, start] = parseInterpolationNode(node, template.content);
             yield* generateInterpolation(content, node.content.loc, start, presetInfos.all, '(', ');\n');
-            const lines = content.split('\n');
-            yield* generateTsFormat(content, start, lines.length <= 1 ? formatBrackets.curly : [
-                lines[0].trim() === '' ? '(' : formatBrackets.curly[0],
-                lines[lines.length - 1].trim() === '' ? ')' : formatBrackets.curly[1],
-            ]);
         }
         else if (node.type === CompilerDOM.NodeTypes.IF) {
             // v-if / v-else-if / v-else
@@ -403,7 +376,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 blockConditions.push((0, language_core_1.toString)([...generateInterpolation(branch.condition.content, branch.condition.loc, undefined, undefined, '(', ')')]
                     .map(code => code[1])));
                 addedBlockCondition = true;
-                yield* generateTsFormat(branch.condition.content, branch.condition.loc.start.offset, formatBrackets.normal);
             }
             yield _ts(` {\n`);
             let prev;
@@ -421,19 +393,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         blockConditions.length = originalBlockConditionsLength;
     }
     function* generateVFor(node, parentEl, componentCtxVar) {
-        const { source, value, key, index } = node.parseResult;
-        const leftExpressionRange = value ? { start: (value ?? key ?? index).loc.start.offset, end: (index ?? key ?? value).loc.end.offset } : undefined;
-        const leftExpressionText = leftExpressionRange ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset) : undefined;
+        const { source } = node.parseResult;
+        const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
         const forBlockVars = [];
         yield _ts(`for (const [`);
         if (leftExpressionRange && leftExpressionText) {
-            const collectAst = createTsAst(node.parseResult, `const [${leftExpressionText}]`);
+            const collectAst = createTsAst(ts, node.parseResult, `const [${leftExpressionText}]`);
             (0, transform_1.collectVars)(ts, collectAst, collectAst, forBlockVars);
             for (const varName of forBlockVars) {
                 localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
             }
             yield _ts([leftExpressionText, 'template', leftExpressionRange.start, presetInfos.all]);
-            yield* generateTsFormat(leftExpressionText, leftExpressionRange.start, formatBrackets.normal);
         }
         yield _ts(`] of __VLS_getVForSourceType`);
         if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -449,7 +419,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield* generateExpectErrorComment();
             yield* generateExtraAutoImport();
             yield _ts('}\n');
-            yield* generateTsFormat(source.content, source.loc.start.offset, formatBrackets.normal);
         }
         for (const varName of forBlockVars) {
             localVars.set(varName, localVars.get(varName) - 1);
@@ -595,12 +564,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         for (const failedExp of propsFailedExps) {
             yield* generateInterpolation(failedExp.loc.source, failedExp.loc, failedExp.loc.start.offset, presetInfos.all, '(', ')');
             yield _ts(';\n');
-            const fb = formatBrackets.normal;
-            if (fb) {
-                yield* generateTsFormat(failedExp.loc.source, failedExp.loc.start.offset, fb);
-            }
         }
-        yield* generateInlineCss(props);
         const vScope = props.find(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && (prop.name === 'scope' || prop.name === 'data'));
         let inScope = false;
         let originalConditionsNum = blockConditions.length;
@@ -646,8 +610,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts(`{\n`);
             let hasProps = false;
             if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                yield* generateTsFormat(slotDir.exp.content, slotDir.exp.loc.start.offset, formatBrackets.params);
-                const slotAst = createTsAst(slotDir, `(${slotDir.exp.content}) => {}`);
+                const slotAst = createTsAst(ts, slotDir, `(${slotDir.exp.content}) => {}`);
                 (0, transform_1.collectVars)(ts, slotAst, slotAst, slotBlockVars);
                 hasProps = true;
                 if (slotDir.exp.content.indexOf(':') === -1) {
@@ -813,35 +776,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 // https://github.com/johnsoncodehk/vue-tsc/issues/67
                 yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, presetInfos.all, '$event => {(', ')}');
                 yield _ts(';\n');
-                yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
             }
         }
     }
     function* appendExpressionNode(prop) {
         if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            const ast = createTsAst(prop.exp, prop.exp.content);
-            let isCompoundExpression = true;
-            if (ast.statements.length === 1) {
-                ts.forEachChild(ast, child_1 => {
-                    if (ts.isExpressionStatement(child_1)) {
-                        ts.forEachChild(child_1, child_2 => {
-                            if (ts.isArrowFunction(child_2)) {
-                                isCompoundExpression = false;
-                            }
-                            else if (ts.isIdentifier(child_2)) {
-                                isCompoundExpression = false;
-                            }
-                        });
-                    }
-                    else if (ts.isFunctionDeclaration(child_1)) {
-                        isCompoundExpression = false;
-                    }
-                });
-            }
             let prefix = '(';
             let suffix = ')';
             let isFirstMapping = true;
-            if (isCompoundExpression) {
+            const ast = createTsAst(ts, prop.exp, prop.exp.content);
+            const _isCompoundExpression = isCompoundExpression(ts, ast);
+            if (_isCompoundExpression) {
                 yield _ts('$event => {\n');
                 localVars.set('$event', (localVars.get('$event') ?? 0) + 1);
                 prefix = '';
@@ -851,19 +796,18 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 }
             }
             yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, () => {
-                if (isCompoundExpression && isFirstMapping) {
+                if (_isCompoundExpression && isFirstMapping) {
                     isFirstMapping = false;
                     return presetInfos.allWithHiddenParam;
                 }
                 return presetInfos.all;
             }, prefix, suffix);
-            if (isCompoundExpression) {
+            if (_isCompoundExpression) {
                 localVars.set('$event', localVars.get('$event') - 1);
                 yield _ts(';\n');
                 yield* generateExtraAutoImport();
                 yield _ts('}\n');
             }
-            yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, isCompoundExpression ? formatBrackets.event : formatBrackets.normal);
         }
         else {
             yield _ts(`() => {}`);
@@ -942,9 +886,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     const isShorthand = prop.arg?.loc.start.offset === prop.exp?.loc.start.offset; // vue 3.4+
                     if (!isShorthand) {
                         yield* generateInterpolation(prop.exp.loc.source, prop.exp.loc, prop.exp.loc.start.offset, caps_all, '(', ')');
-                        if (mode === 'normal') {
-                            yield* generateTsFormat(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
-                        }
                     }
                     else {
                         const propVariableName = (0, shared_1.camelize)(prop.exp.loc.source);
@@ -1033,9 +974,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, caps_all, '(', ')');
                 yield _ts(['', 'template', prop.exp.loc.end.offset, presetInfos.diagnosticOnly]);
                 yield _ts(', ');
-                if (mode === 'normal') {
-                    yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
-                }
             }
             else {
                 // comment this line to avoid affecting comments in prop expressions
@@ -1043,32 +981,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             }
         }
     }
-    function* generateInlineCss(props) {
-        for (const prop of props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-                && prop.name === 'bind'
-                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.arg.content === 'style'
-                && prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
-                const start = prop.arg.loc.source.indexOf(endCrt) + 1;
-                const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.substring(start, end);
-                yield _inlineCss(`x { `);
-                yield _inlineCss([
-                    content,
-                    'template',
-                    prop.arg.loc.start.offset + start,
-                    (0, utils_1.enableAllFeatures)({
-                        format: false,
-                        structure: false,
-                    }),
-                ]);
-                yield _inlineCss(` }\n`);
-            }
-        }
-    }
     function* generateDirectives(node) {
         for (const prop of node.props) {
             if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -1081,7 +993,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
                     yield* generateInterpolation(prop.arg.content, prop.arg.loc, prop.arg.loc.start.offset + prop.arg.loc.source.indexOf(prop.arg.content), presetInfos.all, '(', ')');
                     yield _ts(';\n');
-                    yield* generateTsFormat(prop.arg.content, prop.arg.loc.start.offset, formatBrackets.normal);
                 }
                 yield _ts(['', 'template', prop.loc.start.offset, presetInfos.diagnosticOnly]);
                 yield _ts(`__VLS_directiveFunction(__VLS_ctx.`);
@@ -1101,7 +1012,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     yield _ts(['', 'template', prop.exp.loc.start.offset, presetInfos.diagnosticOnly]);
                     yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, presetInfos.all, '(', ')');
                     yield _ts(['', 'template', prop.exp.loc.end.offset, presetInfos.diagnosticOnly]);
-                    yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
                 }
                 else {
                     yield _ts('undefined');
@@ -1332,20 +1242,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             offset += part.length + 1;
         }
     }
-    function* generateTsFormat(code, offset, formatWrapper) {
-        yield _tsFormat(formatWrapper[0]);
-        yield _tsFormat([
-            code,
-            'template',
-            offset,
-            (0, utils_1.mergeFeatureSettings)(presetInfos.disabledAll, {
-                format: true,
-                // autoInserts: true, // TODO: support vue-autoinsert-parentheses
-            }),
-        ]);
-        yield _tsFormat(formatWrapper[1]);
-        yield _tsFormat('\n');
-    }
     function* generateObjectProperty(code, offset, info, astHolder, shouldCamelize = false) {
         if (code.startsWith('[') && code.endsWith(']') && astHolder) {
             yield* generateInterpolation(code, astHolder, offset, info, '', '');
@@ -1373,7 +1269,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
     }
     function* generateInterpolation(_code, astHolder, start, data, prefix, suffix) {
         const code = prefix + _code + suffix;
-        const ast = createTsAst(astHolder, code);
+        const ast = createTsAst(ts, astHolder, code);
         const vars = [];
         for (let [section, offset, onlyError] of (0, transform_1.eachInterpolationSegment)(ts, code, ast, localVars, accessedGlobalVariables, vueCompilerOptions, vars)) {
             if (offset === undefined) {
@@ -1445,15 +1341,74 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
         }
     }
-    function createTsAst(astHolder, text) {
-        if (astHolder.__volar_ast_text !== text) {
-            astHolder.__volar_ast_text = text;
-            astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
-        }
-        return astHolder.__volar_ast;
-    }
 }
 exports.generate = generate;
+function createTsAst(ts, astHolder, text) {
+    if (astHolder.__volar_ast_text !== text) {
+        astHolder.__volar_ast_text = text;
+        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+    }
+    return astHolder.__volar_ast;
+}
+exports.createTsAst = createTsAst;
+function isCompoundExpression(ts, ast) {
+    let result = true;
+    if (ast.statements.length === 1) {
+        ts.forEachChild(ast, child_1 => {
+            if (ts.isExpressionStatement(child_1)) {
+                ts.forEachChild(child_1, child_2 => {
+                    if (ts.isArrowFunction(child_2)) {
+                        result = false;
+                    }
+                    else if (ts.isIdentifier(child_2)) {
+                        result = false;
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(child_1)) {
+                result = false;
+            }
+        });
+    }
+    return result;
+}
+exports.isCompoundExpression = isCompoundExpression;
+function parseInterpolationNode(node, template) {
+    let content = node.content.loc.source;
+    let start = node.content.loc.start.offset;
+    let leftCharacter;
+    let rightCharacter;
+    // fix https://github.com/vuejs/language-tools/issues/1787
+    while ((leftCharacter = template.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
+        start--;
+        content = leftCharacter + content;
+    }
+    while ((rightCharacter = template.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+        content = content + rightCharacter;
+    }
+    return [
+        content,
+        start,
+    ];
+}
+exports.parseInterpolationNode = parseInterpolationNode;
+function parseVForNode(node) {
+    const { value, key, index } = node.parseResult;
+    const leftExpressionRange = (value || key || index)
+        ? {
+            start: (value ?? key ?? index).loc.start.offset,
+            end: (index ?? key ?? value).loc.end.offset,
+        }
+        : undefined;
+    const leftExpressionText = leftExpressionRange
+        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        : undefined;
+    return {
+        leftExpressionRange,
+        leftExpressionText,
+    };
+}
+exports.parseVForNode = parseVForNode;
 function getCanonicalComponentName(tagText) {
     return validTsVarReg.test(tagText)
         ? tagText
@@ -1467,21 +1422,21 @@ function getPossibleOriginalComponentNames(tagText) {
             tagText,
         ])];
 }
-function* eachElementNode(node) {
+function* forEachElementNode(node) {
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         for (const child of node.children) {
-            yield* eachElementNode(child);
+            yield* forEachElementNode(child);
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
         const patchForNode = getVForNode(node);
         if (patchForNode) {
-            yield* eachElementNode(patchForNode);
+            yield* forEachElementNode(patchForNode);
         }
         else {
             yield node;
             for (const child of node.children) {
-                yield* eachElementNode(child);
+                yield* forEachElementNode(child);
             }
         }
     }
@@ -1490,18 +1445,18 @@ function* eachElementNode(node) {
         for (let i = 0; i < node.branches.length; i++) {
             const branch = node.branches[i];
             for (const childNode of branch.children) {
-                yield* eachElementNode(childNode);
+                yield* forEachElementNode(childNode);
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.FOR) {
         // v-for
         for (const child of node.children) {
-            yield* eachElementNode(child);
+            yield* forEachElementNode(child);
         }
     }
 }
-exports.eachElementNode = eachElementNode;
+exports.forEachElementNode = forEachElementNode;
 function needToUnicode(str) {
     return str.indexOf('\\') >= 0 || str.indexOf('\n') >= 0;
 }

package/lib/generators/utils.d.ts

@@ -1,5 +1,4 @@
-import type { Code, CodeAndStack, VueCodeInformation } from '../types';
-export declare function withStack(code: Code): CodeAndStack;
+import type { VueCodeInformation } from '../types';
 export declare function getStack(): string;
 export declare function disableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;
 export declare function enableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;

package/lib/generators/utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeFeatureSettings = exports.enableAllFeatures = exports.disableAllFeatures = exports.getStack = exports.withStack = void 0;
-function withStack(code) {
-    return [code, getStack()];
-}
-exports.withStack = withStack;
+exports.mergeFeatureSettings = exports.enableAllFeatures = exports.disableAllFeatures = exports.getStack = void 0;
 // TODO: import from muggle-string
 function getStack() {
     const stack = new Error().stack;

package/lib/languageModule.d.ts

@@ -1,5 +1,10 @@
 import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
-import type { VueCompilerOptions } from './types';
+import type { VueCompilerOptions, VueLanguagePlugin } from './types';
 import { VueGeneratedCode } from './virtualFile/vueFile';
-export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, isValidGlobalTypesHolder: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack?: boolean): LanguagePlugin<VueGeneratedCode>;
+interface _Plugin extends LanguagePlugin<VueGeneratedCode> {
+    getCanonicalFileName: (fileName: string) => string;
+    pluginContext: Parameters<VueLanguagePlugin>[0];
+}
+export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, useCaseSensitiveFileNames: boolean, getProjectVersion: () => string, getScriptFileNames: () => string[] | Set<string>, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack?: boolean): _Plugin;
+export {};

package/lib/languageModule.js

@@ -35,7 +35,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     ];
     return JSON.stringify(values);
 }
-function createVueLanguagePlugin(ts, getFileName, isValidGlobalTypesHolder, compilerOptions, vueCompilerOptions, codegenStack = false) {
+function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, getProjectVersion, getScriptFileNames, compilerOptions, vueCompilerOptions, codegenStack = false) {
     const allowLanguageIds = new Set(['vue']);
     const pluginContext = {
         modules: {
@@ -59,11 +59,23 @@ function createVueLanguagePlugin(ts, getFileName, isValidGlobalTypesHolder, comp
     if (vueCompilerOptions.extensions.includes('.html')) {
         allowLanguageIds.add('html');
     }
+    const getCanonicalFileName = useCaseSensitiveFileNames
+        ? (fileName) => fileName
+        : (fileName) => fileName.toLowerCase();
+    let canonicalRootFileNames = new Set();
+    let canonicalRootFileNamesVersion;
     return {
+        getCanonicalFileName,
+        pluginContext,
         createVirtualCode(fileId, languageId, snapshot) {
             if (allowLanguageIds.has(languageId)) {
                 const fileName = getFileName(fileId);
-                if (!pluginContext.globalTypesHolder && isValidGlobalTypesHolder(fileName)) {
+                const projectVersion = getProjectVersion();
+                if (projectVersion !== canonicalRootFileNamesVersion) {
+                    canonicalRootFileNames = new Set([...getScriptFileNames()].map(getCanonicalFileName));
+                    canonicalRootFileNamesVersion = projectVersion;
+                }
+                if (!pluginContext.globalTypesHolder && canonicalRootFileNames.has(getCanonicalFileName(fileName))) {
                     pluginContext.globalTypesHolder = fileName;
                 }
                 const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
@@ -83,33 +95,38 @@ function createVueLanguagePlugin(ts, getFileName, isValidGlobalTypesHolder, comp
             code.update(snapshot);
             return code;
         },
-        disposeVirtualCode(fileId, code, files) {
-            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;
-                    }
-                }
-            }
-        },
+        // 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: vueCompilerOptions.extensions.map(ext => ({
                 extension: ext.slice(1),
                 isMixedContent: true,
                 scriptKind: 7,
             })),
-            getScript(rootVirtualCode) {
-                for (const code of (0, language_core_1.forEachEmbeddedCode)(rootVirtualCode)) {
+            getServiceScript(root) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
                     if (code.id.startsWith('script_')) {
                         const lang = code.id.substring('script_'.length);
                         return {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -43,6 +43,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         name: TextRange | undefined;
         nameIsString: boolean;
         type: TextRange | undefined;
+        modifierType?: TextRange | undefined;
         defaultValue: TextRange | undefined;
         required: boolean;
         isModel?: boolean | undefined;

package/lib/parsers/scriptSetupRanges.js

@@ -87,6 +87,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     name,
                     nameIsString: true,
                     type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    modifierType: node.typeArguments && node.typeArguments?.length >= 2 ? _getStartEnd(node.typeArguments[1]) : undefined,
                     defaultValue: undefined,
                     required,
                     isModel: true,