@vue/language-core 2.0.4 → 2.0.6

package/lib/generators/script.js

@@ -978,7 +978,7 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
             classNameWithDot.substring(1),
             'style_' + styleIndex,
             offset + 1,
-            (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }),
+            (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }),
         ]);
         yield _(`'`);
         yield _([

package/lib/generators/template.js

@@ -195,7 +195,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 '',
                 'template',
                 expectedErrorNode.loc.end.offset,
-                (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }),
+                (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }),
             ]);
             yield _ts('\n;\n');
         }
@@ -225,7 +225,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             else {
                 yield _ts(['', 'template', slot.tagRange[0], (0, utils_1.mergeFeatureSettings)(presetInfos.slotNameExport, (0, utils_1.disableAllFeatures)({ __referencesCodeLens: true }))]);
                 yield _ts('default');
-                yield _ts(['', 'template', slot.tagRange[1], (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                yield _ts(['', 'template', slot.tagRange[1], (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             }
             yield _ts(`?(_: typeof ${slot.varName}): any,\n`);
         }
@@ -673,7 +673,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield _ts('.');
                 yield _ts(['', 'template', slotDir.loc.start.offset, { ...presetInfos.slotName, completion: false }]);
                 yield _ts('default');
-                yield _ts(['', 'template', slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#') ? '#'.length : slotDir.loc.source.startsWith('v-slot:') ? 'v-slot:'.length : 0), (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                yield _ts(['', 'template', slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#') ? '#'.length : slotDir.loc.source.startsWith('v-slot:') ? 'v-slot:'.length : 0), (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             }
             yield _ts(['', 'template', (slotDir.arg ?? slotDir).loc.end.offset, presetInfos.diagnosticOnly]);
             if (hasProps) {
@@ -724,7 +724,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield _ts(`(${componentCtxVar}.slots!).`);
                 yield _ts(['', 'template', node.children[0].loc.start.offset, (0, utils_1.disableAllFeatures)({ navigation: true })]);
                 yield _ts('default');
-                yield _ts(['', 'template', node.children[node.children.length - 1].loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                yield _ts(['', 'template', node.children[node.children.length - 1].loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
                 yield _ts(';\n');
             }
         }
@@ -772,17 +772,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     yield _ts(`.`);
                     yield _ts(startCode);
                     yield _ts(`on`);
-                    yield* generateCamelized((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }));
+                    yield* generateCamelized((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }));
                 }
                 else {
                     yield _ts(`[`);
                     yield _ts(startCode);
                     yield _ts(`'`);
-                    yield _ts(['', 'template', prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                    yield _ts(['', 'template', prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
                     yield _ts('on');
-                    yield* generateCamelized((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }));
+                    yield* generateCamelized((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }));
                     yield _ts(`'`);
-                    yield _ts(['', 'template', prop.arg.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                    yield _ts(['', 'template', prop.arg.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
                     yield _ts(`]`);
                 }
                 yield _ts(`) };\n`);
@@ -931,13 +931,41 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     })
                     : caps_attr, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize);
                 yield _ts(': (');
-                if (prop.exp && !(prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY)) { // style='z-index: 2' will compile to {'z-index':'2'}
+                if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
                     const isShorthand = prop.arg?.loc.start.offset === prop.exp?.loc.start.offset; // vue 3.4+
-                    yield* generateInterpolation(prop.exp.loc.source, prop.exp.loc, prop.exp.loc.start.offset, 
-                    // disable completion for shorthand expression
-                    isShorthand ? caps_attr : caps_all, '(', ')');
-                    if (!isShorthand && mode === 'normal') {
-                        yield* generateTsFormat(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
+                    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);
+                        if (validTsVarReg.test(propVariableName)) {
+                            if (!localVars.has(propVariableName)) {
+                                accessedGlobalVariables.add(propVariableName);
+                                yield _ts('__VLS_ctx.');
+                            }
+                            yield* generateCamelized(prop.exp.loc.source, prop.exp.loc.start.offset, caps_all);
+                            if (mode === 'normal') {
+                                yield _ts([
+                                    '',
+                                    'template',
+                                    prop.exp.loc.end.offset,
+                                    (0, utils_1.disableAllFeatures)({
+                                        __hint: {
+                                            setting: 'vue.inlayHints.vBindShorthand',
+                                            label: `="${propVariableName}"`,
+                                            tooltip: [
+                                                `This is a shorthand for \`${prop.exp.loc.source}="${propVariableName}"\`.`,
+                                                'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
+                                                '[More info](https://github.com/vuejs/core/pull/9451)',
+                                            ].join('\n\n'),
+                                        },
+                                    })
+                                ]);
+                            }
+                        }
                     }
                 }
                 else {
@@ -1130,13 +1158,13 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts('__VLS_normalizeSlot(');
             yield _ts(['', 'template', node.loc.start.offset, presetInfos.diagnosticOnly]);
             yield _ts(`${slotsAssignName ?? '__VLS_slots'}[`);
-            yield _ts(['', 'template', node.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', node.loc.start.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             yield _ts(slotNameExpNode?.content ?? `('${getSlotName()?.[0] ?? 'default'}' as const)`);
-            yield _ts(['', 'template', node.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', node.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             yield _ts(']');
-            yield _ts(['', 'template', node.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', node.loc.end.offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             yield _ts(')?.(');
-            yield _ts(['', 'template', startTagOffset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', startTagOffset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             yield _ts('{\n');
         }
         else {
@@ -1269,7 +1297,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         if (needToUnicode(content)) {
             yield _ts(['', 'template', start, info]);
             yield _ts(toUnicode(content));
-            yield _ts(['', 'template', end, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', end, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
         }
         else {
             yield _ts([content, 'template', start, info]);
@@ -1289,7 +1317,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     offset,
                     i === 0
                         ? info
-                        : (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }),
+                        : (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }),
                 ]);
             }
             offset += part.length + 1;
@@ -1320,9 +1348,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             else {
                 yield _ts(['', 'template', offset, info]);
                 yield _ts('"');
-                yield* generateCamelized(code, offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true }));
+                yield* generateCamelized(code, offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }));
                 yield _ts('"');
-                yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+                yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             }
         }
         else {
@@ -1403,9 +1431,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         else {
             yield _ts(['', 'template', offset, info]);
             yield _ts('"');
-            yield _ts([code, 'template', offset, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts([code, 'template', offset, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
             yield _ts('"');
-            yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMappping: true })]);
+            yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
         }
     }
     function createTsAst(astHolder, text) {

package/lib/languageModule.d.ts

@@ -2,4 +2,4 @@ import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
 import { VueGeneratedCode } from './virtualFile/vueFile';
-export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, compilerOptions?: ts.CompilerOptions, _vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean, globalTypesHolder?: string): LanguagePlugin<VueGeneratedCode>;
+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>;

package/lib/languageModule.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVueLanguagePlugin = void 0;
 const language_core_1 = require("@volar/language-core");
 const plugins_1 = require("./plugins");
-const ts_1 = require("./utils/ts");
 const vueFile_1 = require("./virtualFile/vueFile");
-const fileRegistries = [];
-function getVueFileRegistry(key, plugins) {
+const CompilerDOM = require("@vue/compiler-dom");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+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;
@@ -20,9 +23,8 @@ function getVueFileRegistry(key, plugins) {
     }
     return fileRegistry;
 }
-function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, globalTypesHolder) {
+function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     const values = [
-        globalTypesHolder,
         ...Object.keys(vueCompilerOptions)
             .sort()
             .filter(key => key !== 'plugins')
@@ -33,10 +35,23 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, global
     ];
     return JSON.stringify(values);
 }
-function createVueLanguagePlugin(ts, getFileName, compilerOptions = {}, _vueCompilerOptions = {}, codegenStack = false, globalTypesHolder) {
-    const vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)(_vueCompilerOptions);
+function createVueLanguagePlugin(ts, getFileName, isValidGlobalTypesHolder, compilerOptions, vueCompilerOptions, codegenStack = false) {
     const allowLanguageIds = new Set(['vue']);
-    const pluginContext = (0, plugins_1.createPluginContext)(ts, compilerOptions, vueCompilerOptions, codegenStack, globalTypesHolder);
+    const pluginContext = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+        codegenStack,
+        globalTypesHolder: undefined,
+    };
     const plugins = (0, plugins_1.getDefaultVueLanguagePlugins)(pluginContext);
     if (vueCompilerOptions.extensions.includes('.md')) {
         allowLanguageIds.add('markdown');
@@ -44,46 +59,47 @@ function createVueLanguagePlugin(ts, getFileName, compilerOptions = {}, _vueComp
     if (vueCompilerOptions.extensions.includes('.html')) {
         allowLanguageIds.add('html');
     }
-    let generatedCodeRegistry;
     return {
         createVirtualCode(fileId, languageId, snapshot) {
             if (allowLanguageIds.has(languageId)) {
                 const fileName = getFileName(fileId);
-                if (!generatedCodeRegistry) {
-                    pluginContext.globalTypesHolder ??= fileName;
-                    generatedCodeRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, pluginContext.globalTypesHolder), vueCompilerOptions.plugins);
+                if (!pluginContext.globalTypesHolder && isValidGlobalTypesHolder(fileName)) {
+                    pluginContext.globalTypesHolder = fileName;
+                }
+                const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
+                const code = fileRegistry.get(fileId);
+                if (code) {
+                    code.update(snapshot);
+                    return code;
                 }
-                if (generatedCodeRegistry.has(fileId)) {
-                    const reusedResult = generatedCodeRegistry.get(fileId);
-                    reusedResult.update(snapshot);
-                    return reusedResult;
+                else {
+                    const code = new vueFile_1.VueGeneratedCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
+                    fileRegistry.set(fileId, code);
+                    return code;
                 }
-                const vueFile = new vueFile_1.VueGeneratedCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
-                generatedCodeRegistry.set(fileId, vueFile);
-                return vueFile;
             }
         },
-        updateVirtualCode(_fileId, vueFile, snapshot) {
-            vueFile.update(snapshot);
-            return vueFile;
+        updateVirtualCode(_fileId, code, snapshot) {
+            code.update(snapshot);
+            return code;
         },
-        disposeVirtualCode(fileId, vueFile, files) {
-            generatedCodeRegistry?.delete(fileId);
-            if (vueFile.fileName === pluginContext.globalTypesHolder) {
-                if (generatedCodeRegistry?.size) {
-                    for (const [fileName, file] of generatedCodeRegistry) {
-                        pluginContext.globalTypesHolder = fileName;
-                        generatedCodeRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, pluginContext.globalTypesHolder), vueCompilerOptions.plugins);
-                        files?.set(fileId, file.languageId, 
+        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
-                        { ...file.snapshot });
+                        files?.delete(fileId);
+                        files?.set(fileId, code.languageId, code.snapshot);
                         break;
                     }
                 }
-                else {
-                    generatedCodeRegistry = undefined;
-                    pluginContext.globalTypesHolder = undefined;
-                }
             }
         },
         typescript: {
@@ -109,6 +125,9 @@ function createVueLanguagePlugin(ts, getFileName, compilerOptions = {}, _vueComp
             },
         },
     };
+    function getFileRegistry(isGlobalTypesHolder) {
+        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    }
 }
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
 //# sourceMappingURL=languageModule.js.map

package/lib/plugins.d.ts

@@ -1,16 +1,4 @@
-import * as CompilerDOM from '@vue/compiler-dom';
-import type * as ts from 'typescript';
-import { type VueCompilerOptions, type VueLanguagePlugin } from './types';
-export declare function createPluginContext(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean, globalTypesHolder: string | undefined): {
-    modules: {
-        typescript: typeof import("typescript");
-        '@vue/compiler-dom': typeof CompilerDOM;
-    };
-    compilerOptions: ts.CompilerOptions;
-    vueCompilerOptions: VueCompilerOptions;
-    codegenStack: boolean;
-    globalTypesHolder: string | undefined;
-};
+import { type VueLanguagePlugin } from './types';
 export declare function getDefaultVueLanguagePlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): {
     version: 2;
     name?: string | undefined;
@@ -22,13 +10,13 @@ export declare function getDefaultVueLanguagePlugins(pluginContext: Parameters<V
         end: number;
         newText: string;
     }): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
-    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
-    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+    resolveTemplateCompilerOptions?(options: import("@vue/compiler-dom").CompilerOptions): import("@vue/compiler-dom").CompilerOptions;
+    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;
-    }): CompilerDOM.CodegenResult | undefined;
+    }): import("@vue/compiler-dom").CodegenResult | undefined;
     getEmbeddedCodes?(fileName: string, sfc: import("./types").Sfc): {
         id: string;
         lang: string;

package/lib/plugins.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultVueLanguagePlugins = exports.createPluginContext = void 0;
-const CompilerDOM = require("@vue/compiler-dom");
+exports.getDefaultVueLanguagePlugins = void 0;
 const file_html_1 = require("./plugins/file-html");
 const file_md_1 = require("./plugins/file-md");
 const file_vue_1 = require("./plugins/file-vue");
@@ -12,26 +11,6 @@ const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
 const vue_template_html_1 = require("./plugins/vue-template-html");
 const vue_tsx_1 = require("./plugins/vue-tsx");
 const types_1 = require("./types");
-const CompilerVue2 = require("./utils/vue2TemplateCompiler");
-function createPluginContext(ts, compilerOptions, vueCompilerOptions, codegenStack, globalTypesHolder) {
-    const pluginCtx = {
-        modules: {
-            '@vue/compiler-dom': vueCompilerOptions.target < 3
-                ? {
-                    ...CompilerDOM,
-                    compile: CompilerVue2.compile,
-                }
-                : CompilerDOM,
-            typescript: ts,
-        },
-        compilerOptions,
-        vueCompilerOptions,
-        codegenStack,
-        globalTypesHolder,
-    };
-    return pluginCtx;
-}
-exports.createPluginContext = createPluginContext;
 function getDefaultVueLanguagePlugins(pluginContext) {
     const plugins = [
         file_md_1.default, // .md for VitePress
@@ -46,7 +25,15 @@ function getDefaultVueLanguagePlugins(pluginContext) {
         ...pluginContext.vueCompilerOptions.plugins,
     ];
     const pluginInstances = plugins
-        .map(plugin => plugin(pluginContext))
+        .map(plugin => {
+        try {
+            return plugin(pluginContext);
+        }
+        catch (err) {
+            console.warn('[Vue] Failed to create plugin', err);
+        }
+    })
+        .filter((plugin) => !!plugin)
         .sort((a, b) => {
         const aOrder = a.order ?? 0;
         const bOrder = b.order ?? 0;
@@ -55,7 +42,7 @@ function getDefaultVueLanguagePlugins(pluginContext) {
     return pluginInstances.filter((plugin) => {
         const valid = plugin.version === types_1.pluginVersion;
         if (!valid) {
-            console.warn(`Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected ${JSON.stringify(types_1.pluginVersion)} but got ${JSON.stringify(plugin.version)}`);
+            console.warn(`[Vue] Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected ${JSON.stringify(types_1.pluginVersion)} but got ${JSON.stringify(plugin.version)}`);
         }
         return valid;
     });

package/lib/types.d.ts

@@ -18,7 +18,7 @@ export interface VueCodeInformation extends CodeInformation {
         paddingRight?: boolean;
         paddingLeft?: boolean;
     };
-    __combineLastMappping?: boolean;
+    __combineLastMapping?: boolean;
 }
 export type CodeAndStack = [code: Code, stack: string];
 export type Code = Segment<VueCodeInformation>;

package/lib/utils/ts.js

@@ -121,11 +121,11 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
                     return require(resolvedPath);
                 }
                 else {
-                    console.warn('Load plugin failed:', pluginPath);
+                    console.warn('[Vue] Load plugin failed:', pluginPath);
                 }
             }
             catch (error) {
-                console.warn('Load plugin failed:', pluginPath, error);
+                console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
             }
             return [];
         })

package/lib/virtualFile/computedFiles.js

@@ -172,7 +172,7 @@ function computedPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codege
                     }
                     mapping.source = undefined;
                 }
-                if (mapping.data.__combineLastMappping) {
+                if (mapping.data.__combineLastMapping) {
                     lastValidMapping.sourceOffsets.push(...mapping.sourceOffsets);
                     lastValidMapping.generatedOffsets.push(...mapping.generatedOffsets);
                     lastValidMapping.lengths.push(...mapping.lengths);
@@ -185,7 +185,7 @@ function computedPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codege
             return {
                 file,
                 snapshot,
-                mappings: mappings.filter(mapping => !mapping.data.__combineLastMappping),
+                mappings: mappings.filter(mapping => !mapping.data.__combineLastMapping),
                 codegenStacks: (0, language_core_1.buildStacks)(file.content, file.contentStacks),
             };
         });

package/lib/virtualFile/computedMappings.d.ts

@@ -1,4 +1,4 @@
-import { Mapping } from '@volar/language-core';
+import { CodeMapping } from '@volar/language-core';
 import type * as ts from 'typescript';
-import type { Sfc, VueCodeInformation } from '../types';
-export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => Mapping<VueCodeInformation>[];
+import type { Sfc } from '../types';
+export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => CodeMapping[];

package/lib/virtualFile/computedMappings.js

@@ -18,7 +18,7 @@ function computedMappings(snapshot, sfc) {
                 (0, language_core_1.replaceSourceRange)(str, undefined, block.startTagEnd, block.endTagStart, '\n\n');
             }
         }
-        return str
+        const mappings = str
             .filter(s => typeof s !== 'string')
             .map((m) => {
             const text = m[0];
@@ -30,6 +30,36 @@ function computedMappings(snapshot, sfc) {
                 data: m[3],
             };
         });
+        // fix folding range end position failed to mapping
+        for (const block of [
+            sfc.script,
+            sfc.scriptSetup,
+            sfc.template,
+            ...sfc.styles,
+            ...sfc.customBlocks,
+        ]) {
+            const offsets = [];
+            if (block) {
+                let content = block.content;
+                if (content.endsWith('\r\n')) {
+                    content = content.slice(0, -2);
+                }
+                else if (content.endsWith('\n')) {
+                    content = content.slice(0, -1);
+                }
+                const offset = content.lastIndexOf('\n') + 1;
+                offsets.push(block.startTagEnd + offset);
+            }
+            if (offsets.length) {
+                mappings.push({
+                    sourceOffsets: offsets,
+                    generatedOffsets: offsets,
+                    lengths: offsets.map(() => 0),
+                    data: (0, utils_1.disableAllFeatures)({ structure: true }),
+                });
+            }
+        }
+        return mappings;
     });
 }
 exports.computedMappings = computedMappings;

package/lib/virtualFile/vueFile.d.ts

@@ -14,12 +14,12 @@ export declare class VueGeneratedCode implements VirtualCode {
     _snapshot: Signal<ts.IScriptSnapshot>;
     getVueSfc: () => import("@vue/compiler-sfc").SFCParseResult | undefined;
     sfc: import("../types").Sfc;
-    getMappings: () => import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    getMappings: () => import("@volar/language-core").CodeMapping[];
     getEmbeddedCodes: () => VirtualCode[];
     codegenStacks: Stack[];
     get embeddedCodes(): VirtualCode[];
     get snapshot(): ts.IScriptSnapshot;
-    get mappings(): import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    get mappings(): import("@volar/language-core").CodeMapping[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript'), codegenStack: boolean);
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.0.4",
+	"version": "2.0.6",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.1.0",
+		"@volar/language-core": "~2.1.2",
 		"@vue/compiler-dom": "^3.4.0",
 		"@vue/shared": "^3.4.0",
 		"computeds": "^0.0.1",
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "241300968fd3084c7c09139d05691a51a7800fdc"
+	"gitHead": "feb990ccec85f6330bba37c8b1d1287f0980274c"
 }