@vue/language-core 2.0.18 → 2.0.20

package/lib/codegen/script/index.js

@@ -40,7 +40,7 @@ function* generateScript(options) {
         const isExportRawObject = exportDefault
             && options.sfc.script.content[exportDefault.expression.start] === '{';
         if (options.sfc.scriptSetup && options.scriptSetupRanges) {
-            yield (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+            yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
             if (exportDefault) {
                 yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
                 yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
@@ -99,7 +99,7 @@ function* generateScript(options) {
         }
     }
     else if (options.sfc.scriptSetup && options.scriptSetupRanges) {
-        yield (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+        yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
         yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
     }
     yield common_1.endOfLine;

package/lib/codegen/script/internalComponent.js

@@ -6,7 +6,8 @@ const component_1 = require("./component");
 const template_1 = require("./template");
 function* generateInternalComponent(options, ctx, templateCodegenCtx) {
     if (options.sfc.scriptSetup && options.scriptSetupRanges) {
-        yield `const __VLS_internalComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+        yield `let __VLS_defineComponent!: typeof import('${options.vueCompilerOptions.lib}').defineComponent${common_1.endOfLine}`;
+        yield `const __VLS_internalComponent = __VLS_defineComponent({${common_1.newLine}`;
         yield `setup() {${common_1.newLine}`;
         yield `return {${common_1.newLine}`;
         if (ctx.bypassDefineComponent) {
@@ -48,7 +49,7 @@ function* generateInternalComponent(options, ctx, templateCodegenCtx) {
         yield `})${common_1.endOfLine}`; // defineComponent {
     }
     else if (options.sfc.script) {
-        yield `const __VLS_internalComponent = (await import('./${options.fileBaseName}')).default${common_1.endOfLine}`;
+        yield `let __VLS_internalComponent!: typeof import('./${options.fileBaseName}').default${common_1.endOfLine}`;
     }
     else {
         yield `const __VLS_internalComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({})${common_1.endOfLine}`;

package/lib/codegen/script/scriptSetup.d.ts

@@ -2,5 +2,5 @@ import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc } from '../../types';
 import type { ScriptCodegenContext } from './context';
 import { ScriptCodegenOptions } from './index';
-export declare function generateScriptSetupImports(scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Code;
+export declare function generateScriptSetupImports(scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
 export declare function generateScriptSetup(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/scriptSetup.js

@@ -5,13 +5,14 @@ const common_1 = require("../common");
 const component_1 = require("./component");
 const index_1 = require("./index");
 const template_1 = require("./template");
-function generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
-    return [
-        scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)) + common_1.newLine,
+function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
+    yield [
+        scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)),
         'scriptSetup',
         0,
         index_1.codeFeatures.all,
     ];
+    yield common_1.newLine;
 }
 exports.generateScriptSetupImports = generateScriptSetupImports;
 function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
@@ -341,9 +342,9 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
     yield common_1.endOfLine;
 }
 function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
-    yield `let __VLS_modelEmitsType!: {}`;
-    if (scriptSetupRanges.defineProp.length) {
-        yield ` & ReturnType<typeof import('${options.vueCompilerOptions.lib}').defineEmits<{${common_1.newLine}`;
+    yield `const __VLS_modelEmitsType = `;
+    if (scriptSetupRanges.defineProp.filter(p => p.isModel).length) {
+        yield `(await import('${options.vueCompilerOptions.lib}')).defineEmits<{${common_1.newLine}`;
         for (const defineProp of scriptSetupRanges.defineProp) {
             if (!defineProp.isModel) {
                 continue;
@@ -362,7 +363,10 @@ function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
             }
             yield `]${common_1.endOfLine}`;
         }
-        yield `}>>`;
+        yield `}>()`;
+    }
+    else {
+        yield `{}`;
     }
     yield common_1.endOfLine;
 }

package/lib/codegen/template/element.js

@@ -85,13 +85,14 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
         yield common_1.endOfLine;
     }
     else if (!isComponentTag) {
+        yield `// @ts-ignore${common_1.newLine}`;
         yield `const ${var_originalComponent} = ({} as `;
         for (const componentName of possibleOriginalNames) {
             yield `'${componentName}' extends keyof typeof __VLS_ctx ? { '${getCanonicalComponentName(node.tag)}': typeof __VLS_ctx`;
             yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, componentName);
             yield ` }: `;
         }
-        yield `typeof __VLS_resolvedLocalAndGlobalComponents)`;
+        yield `typeof __VLS_resolvedLocalAndGlobalComponents)${common_1.newLine}`;
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, getCanonicalComponentName(node.tag), startTagOffset, ctx.codeFeatures.verification);
         yield common_1.endOfLine;
         // hover support
@@ -135,6 +136,7 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     else {
         yield `const ${var_originalComponent} = {} as any${common_1.endOfLine}`;
     }
+    yield `// @ts-ignore${common_1.newLine}`;
     yield `const ${var_functionalComponent} = __VLS_asFunctionalComponent(${var_originalComponent}, new ${var_originalComponent}({`;
     yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, false);
     yield `}))${common_1.endOfLine}`;
@@ -157,7 +159,7 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     componentCtxVar = var_defineComponentCtx;
     currentComponent = node;
     for (const failedExp of propsFailedExps) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.loc.source, failedExp.loc, failedExp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
         yield common_1.endOfLine;
     }
     yield* generateVScope(options, ctx, node, props);
@@ -195,7 +197,7 @@ function* generateElement(options, ctx, node, currentComponent, componentCtxVar)
     yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props, true, propsFailedExps), `}`);
     yield `)${common_1.endOfLine}`;
     for (const failedExp of propsFailedExps) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.loc.source, failedExp.loc, failedExp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
         yield common_1.endOfLine;
     }
     yield* generateVScope(options, ctx, node, node.props);

package/lib/codegen/template/elementEvents.js

@@ -51,14 +51,6 @@ function* generateElementEvents(options, ctx, node, componentVar, componentInsta
             yield* generateEventExpression(options, ctx, prop);
             yield `}${common_1.endOfLine}`;
         }
-        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name === 'on'
-            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            // for vue 2 nameless event
-            // https://github.com/johnsoncodehk/vue-tsc/issues/67
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '$event => {(', ')}');
-            yield common_1.endOfLine;
-        }
     }
     return usedComponentEventsVar;
 }
@@ -104,7 +96,7 @@ function* generateEventExpression(options, ctx, prop) {
         const ast = (0, common_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
         const _isCompoundExpression = isCompoundExpression(options.ts, ast);
         if (_isCompoundExpression) {
-            yield `$event => {${common_1.newLine}`;
+            yield `(...[$event]) => {${common_1.newLine}`;
             ctx.addLocalVariable('$event');
             prefix = '';
             suffix = '';

package/lib/codegen/template/elementProps.d.ts

@@ -2,4 +2,8 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], enableCodeFeatures: boolean, propsFailedExps?: CompilerDOM.SimpleExpressionNode[]): Generator<Code>;
+export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], enableCodeFeatures: boolean, propsFailedExps?: {
+    node: CompilerDOM.SimpleExpressionNode;
+    prefix: string;
+    suffix: string;
+}[]): Generator<Code>;

package/lib/codegen/template/elementProps.js

@@ -31,22 +31,23 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                     yield `...{ '${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any }, `;
                 }
             }
-            else {
-                if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                    && prop.arg.loc.source.startsWith('[')
-                    && prop.arg.loc.source.endsWith(']')) {
-                    propsFailedExps?.push(prop.arg);
-                }
-                if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                    propsFailedExps?.push(prop.exp);
-                }
+            else if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.arg.loc.source.startsWith('[')
+                && prop.arg.loc.source.endsWith(']')) {
+                propsFailedExps?.push({ node: prop.arg, prefix: '(', suffix: ')' });
+                propsFailedExps?.push({ node: prop.exp, prefix: '() => {', suffix: '}' });
+            }
+            else if (!prop.arg
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                propsFailedExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
             }
         }
     }
     for (const prop of props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && (prop.name === 'bind' || prop.name === 'model')
-            && (prop.name === 'model' || prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)
+            && ((prop.name === 'bind' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)
+                || prop.name === 'model')
             && (!prop.exp || prop.exp.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)) {
             let propName;
             if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -60,7 +61,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
             if (propName === undefined
                 || options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern))) {
                 if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                    propsFailedExps?.push(prop.exp);
+                    propsFailedExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
                 }
                 continue;
             }

package/lib/codegen/template/index.d.ts

@@ -15,4 +15,3 @@ export interface TemplateCodegenOptions {
 }
 export declare function generateTemplate(options: TemplateCodegenOptions): Generator<Code, TemplateCodegenContext>;
 export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;
-export declare function isFragment(node: CompilerDOM.IfNode | CompilerDOM.ForNode): boolean | undefined;

package/lib/codegen/template/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFragment = exports.forEachElementNode = exports.generateTemplate = void 0;
+exports.forEachElementNode = exports.generateTemplate = void 0;
 const CompilerDOM = require("@vue/compiler-dom");
 const common_1 = require("../common");
 const context_1 = require("./context");
@@ -138,8 +138,4 @@ function* forEachElementNode(node) {
     }
 }
 exports.forEachElementNode = forEachElementNode;
-function isFragment(node) {
-    return node.codegenNode && 'consequent' in node.codegenNode && 'tag' in node.codegenNode.consequent && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
-}
-exports.isFragment = isFragment;
 //# sourceMappingURL=index.js.map

package/lib/codegen/template/vFor.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVForNode = exports.generateVFor = void 0;
 const CompilerDOM = require("@vue/compiler-dom");
 const common_1 = require("../common");
-const index_1 = require("./index");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
@@ -34,17 +33,25 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     for (const varName of forBlockVars) {
         ctx.addLocalVariable(varName);
     }
+    let isFragment = true;
     for (const argument of node.codegenNode?.children.arguments ?? []) {
         if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
-            && argument.returns.type === CompilerDOM.NodeTypes.VNODE_CALL
-            && argument.returns.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && argument.returns?.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
+                isFragment = false;
+                continue;
+            }
             for (const prop of argument.returns.props.properties) {
-                yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.value.loc.source, prop.value.loc, prop.value.loc.start.offset, ctx.codeFeatures.all, '(', ')');
-                yield common_1.endOfLine;
+                if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                    && !prop.value.isStatic) {
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.value.content, prop.value.loc, prop.value.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+                    yield common_1.endOfLine;
+                }
             }
         }
     }
-    if ((0, index_1.isFragment)(node)) {
+    if (isFragment) {
         yield* ctx.resetDirectiveComments('end of v-for start');
     }
     let prev;

package/lib/codegen/template/vIf.js

@@ -4,7 +4,6 @@ exports.generateVIf = void 0;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const common_1 = require("../common");
-const index_1 = require("./index");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
@@ -33,7 +32,7 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
             yield ` `;
         }
         yield `{${common_1.newLine}`;
-        if ((0, index_1.isFragment)(node)) {
+        if (isFragment(node)) {
             yield* ctx.resetDirectiveComments('end of v-if start');
         }
         let prev;
@@ -50,4 +49,10 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
     ctx.blockConditions.length = originalBlockConditionsLength;
 }
 exports.generateVIf = generateVIf;
+function isFragment(node) {
+    return node.codegenNode
+        && 'consequent' in node.codegenNode
+        && 'tag' in node.codegenNode.consequent
+        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
+}
 //# sourceMappingURL=vIf.js.map

package/lib/languageModule.d.ts

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

package/lib/languageModule.js

@@ -38,7 +38,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     ];
     return JSON.stringify(values);
 }
-function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, getProjectVersion, getScriptFileNames, compilerOptions, vueCompilerOptions) {
+function createVueLanguagePlugin(ts, asFileName, getProjectVersion, isRootFile, compilerOptions, vueCompilerOptions) {
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': vueCompilerOptions.target < 3
@@ -57,38 +57,30 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
     const vueSfcPlugin = (0, file_vue_1.default)(pluginContext);
     const vitePressSfcPlugin = (0, file_md_1.default)(pluginContext);
     const petiteVueSfcPlugin = (0, file_html_1.default)(pluginContext);
-    const getCanonicalFileName = useCaseSensitiveFileNames
-        ? (fileName) => fileName
-        : (fileName) => fileName.toLowerCase();
-    let canonicalRootFileNames = new Set();
     let canonicalRootFileNamesVersion;
     return {
-        getCanonicalFileName,
-        pluginContext,
         getLanguageId(scriptId) {
-            if (vueCompilerOptions.extensions.some(ext => scriptId.endsWith(ext))) {
+            if (vueCompilerOptions.extensions.some(ext => asFileName(scriptId).endsWith(ext))) {
                 return 'vue';
             }
-            if (vueCompilerOptions.vitePressExtensions.some(ext => scriptId.endsWith(ext))) {
+            if (vueCompilerOptions.vitePressExtensions.some(ext => asFileName(scriptId).endsWith(ext))) {
                 return 'markdown';
             }
-            if (vueCompilerOptions.petiteVueExtensions.some(ext => scriptId.endsWith(ext))) {
+            if (vueCompilerOptions.petiteVueExtensions.some(ext => asFileName(scriptId).endsWith(ext))) {
                 return 'html';
             }
         },
         createVirtualCode(scriptId, languageId, snapshot) {
             if (languageId === 'vue' || languageId === 'markdown' || languageId === 'html') {
-                const fileName = getFileName(scriptId);
-                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 fileName = asFileName(scriptId);
+                if (!pluginContext.globalTypesHolder && getProjectVersion() !== canonicalRootFileNamesVersion) {
+                    canonicalRootFileNamesVersion = getProjectVersion();
+                    if (isRootFile(fileName)) {
+                        pluginContext.globalTypesHolder = fileName;
+                    }
                 }
                 const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
-                const code = fileRegistry.get(scriptId);
+                const code = fileRegistry.get(fileName);
                 if (code) {
                     code.update(snapshot);
                     return code;
@@ -99,7 +91,7 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                         : languageId === 'markdown'
                             ? [vitePressSfcPlugin, ...basePlugins]
                             : [vueSfcPlugin, ...basePlugins], ts);
-                    fileRegistry.set(scriptId, code);
+                    fileRegistry.set(fileName, code);
                     return code;
                 }
             }

package/lib/plugins/file-md.js

@@ -59,8 +59,16 @@ const plugin = () => {
             }
             return sfc;
             function transformRange(block) {
-                block.loc.start.offset = file2VueSourceMap.getSourceOffset(block.loc.start.offset)?.[0] ?? -1;
-                block.loc.end.offset = file2VueSourceMap.getSourceOffset(block.loc.end.offset)?.[0] ?? -1;
+                block.loc.start.offset = -1;
+                block.loc.end.offset = -1;
+                for (const [start] of file2VueSourceMap.getSourceOffsets(block.loc.start.offset)) {
+                    block.loc.start.offset = start;
+                    break;
+                }
+                for (const [end] of file2VueSourceMap.getSourceOffsets(block.loc.end.offset)) {
+                    block.loc.end.offset = end;
+                    break;
+                }
             }
         }
     };

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

@@ -7,7 +7,6 @@ const vFor_1 = require("../codegen/template/vFor");
 const CompilerDOM = require("@vue/compiler-dom");
 const codeFeatures = {
     format: true,
-    // autoInserts: true, // TODO: support vue-autoinsert-parentheses
 };
 const formatBrackets = {
     normal: ['`${', '}`;'],

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

@@ -68,7 +68,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
     lang: () => string;
     generatedScript: () => {
         codes: Code[];
-        linkedCodeMappings: Mapping<any>[];
+        linkedCodeMappings: Mapping<unknown>[];
     };
     generatedTemplate: () => {
         codes: Code[];

package/lib/virtualFile/computedFiles.js

@@ -149,21 +149,30 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
     return (0, computeds_1.computed)(() => {
         return codes().map(_file => {
             const { code, snapshot } = _file();
-            const mappings = (0, language_core_1.buildMappings)(code.content);
+            const mappings = (0, language_core_1.buildMappings)(code.content.map(segment => {
+                if (typeof segment === 'string') {
+                    return segment;
+                }
+                const source = segment[1];
+                if (source === undefined) {
+                    return segment;
+                }
+                const block = nameToBlock()[source];
+                if (!block) {
+                    // console.warn('Unable to find block: ' + source);
+                    return segment;
+                }
+                return [
+                    segment[0],
+                    undefined,
+                    segment[2] + block.startTagEnd,
+                    segment[3],
+                ];
+            }));
             const newMappings = [];
             let lastValidMapping;
             for (let i = 0; i < mappings.length; i++) {
                 const mapping = mappings[i];
-                if (mapping.source !== undefined) {
-                    const block = nameToBlock()[mapping.source];
-                    if (block) {
-                        mapping.sourceOffsets = mapping.sourceOffsets.map(offset => offset + block.startTagEnd);
-                    }
-                    else {
-                        // ignore
-                    }
-                    mapping.source = undefined;
-                }
                 if (mapping.data.__combineOffsetMapping !== undefined) {
                     const offsetMapping = mappings[i - mapping.data.__combineOffsetMapping];
                     if (typeof offsetMapping === 'string' || !offsetMapping) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.0.18",
+	"version": "2.0.20",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.2.4",
+		"@volar/language-core": "~2.3.0-alpha.14",
 		"@vue/compiler-dom": "^3.4.0",
 		"@vue/shared": "^3.4.0",
 		"computeds": "^0.0.1",
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "7aac2805f03b17e4c624335f509d502002bb75a8"
+	"gitHead": "e1a5d2f136bf60a772c9655f9f5474c7f71a2ff9"
 }