@vue/language-core 2.2.8 → 3.0.0-alpha.2

package/index.d.ts

@@ -5,9 +5,8 @@ export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
 export * from './lib/types';
 export * from './lib/utils/parseSfc';
+export * from './lib/utils/shared';
 export * from './lib/utils/ts';
 export * from './lib/virtualFile/vueFile';
 export { tsCodegen } from './lib/plugins/vue-tsx';
-export * from './lib/utils/shared';
 export * from '@volar/language-core';
-export type * as CompilerDOM from '@vue/compiler-dom';

package/index.js

@@ -22,10 +22,10 @@ __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
 __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
+__exportStar(require("./lib/utils/shared"), exports);
 __exportStar(require("./lib/utils/ts"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);
 var vue_tsx_1 = require("./lib/plugins/vue-tsx");
 Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
-__exportStar(require("./lib/utils/shared"), exports);
 __exportStar(require("@volar/language-core"), exports);
 //# sourceMappingURL=index.js.map

package/lib/codegen/globalTypes.js

@@ -24,7 +24,6 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
     }
     text += `
 ; declare global {
-	const __VLS_intrinsicElements: __VLS_IntrinsicElements;
 	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
 	const __VLS_unref: typeof import('${lib}').unref;
 	const __VLS_placeholder: any;
@@ -100,9 +99,6 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
 		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
 	>>;
-	type __VLS_OmitStringIndex<T> = {
-		[K in keyof T as string extends K ? never : K]: T[K];
-	};
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
@@ -118,10 +114,8 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		key: keyof T,
 		index: number,
 	][];
-	// @ts-ignore
-	function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
-	// @ts-ignore
-	function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+	function __VLS_getSlotParameters<S, D extends S>(slot: S, decl?: D):
+		__VLS_PickNotAny<NonNullable<D>, (...args: any) => any> extends (...args: infer P) => any ? P : any[];
 	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('${lib}').ObjectDirective
 		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
 		: T extends (...args: any) => any
@@ -144,7 +138,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
 	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
-	function __VLS_asFunctionalSlot<S>(slot: S): (props: NonNullable<S> extends (props: infer P) => any ? P : {}) => void;
+	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
 	function __VLS_tryAsConstant<const T>(t: T): T;
 }
 `;

package/lib/codegen/script/component.js

@@ -111,15 +111,23 @@ function* generateEmitsOption(options, scriptSetupRanges) {
 function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
     const codes = [];
     if (ctx.generatedPropsType) {
-        codes.push({
-            optionExp: [
-                `{} as `,
-                scriptSetupRanges.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
-                `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
-                scriptSetupRanges.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
-            ].join(''),
-            typeOptionExp: `{} as __VLS_PublicProps`,
-        });
+        if (options.vueCompilerOptions.target >= 3.6) {
+            codes.push({
+                optionExp: '{}',
+                typeOptionExp: `{} as __VLS_PublicProps`,
+            });
+        }
+        else {
+            codes.push({
+                optionExp: [
+                    `{} as `,
+                    scriptSetupRanges.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
+                    `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
+                    scriptSetupRanges.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
+                ].join(''),
+                typeOptionExp: `{} as __VLS_PublicProps`,
+            });
+        }
     }
     if (scriptSetupRanges.defineProps?.arg) {
         const { arg } = scriptSetupRanges.defineProps;
@@ -146,6 +154,10 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
     const useTypeOption = options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionExp);
     const useOption = !useTypeOption || scriptSetupRanges.withDefaults;
     if (useTypeOption) {
+        if (options.vueCompilerOptions.target >= 3.6
+            && scriptSetupRanges.withDefaults?.arg) {
+            yield `__defaults: __VLS_withDefaultsArg,${utils_1.newLine}`;
+        }
         if (codes.length === 1) {
             yield `__typeProps: `;
             yield codes[0].typeOptionExp;

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

@@ -9,7 +9,6 @@ export interface ScriptCodegenOptions {
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
     sfc: Sfc;
-    edited: boolean;
     fileName: string;
     lang: string;
     scriptRanges: ScriptRanges | undefined;

package/lib/codegen/script/index.js

@@ -27,7 +27,7 @@ function* generateScript(options) {
         }
     }
     else {
-        yield `/* placeholder */`;
+        yield `/// <reference path="./__VLS_fake.d.ts" />`;
     }
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script.src);
@@ -105,9 +105,6 @@ function* generateScript(options) {
         const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
         yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
     }
-    if (options.edited) {
-        yield `type __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${utils_1.endOfLine}`;
-    }
     yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
     if (options.appendGlobalTypes) {
         yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions);

package/lib/codegen/script/scriptSetup.js

@@ -78,15 +78,6 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
 }
 function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, syntax) {
     let setupCodeModifies = [];
-    for (const { comments } of scriptSetupRanges.defineProp) {
-        if (comments) {
-            setupCodeModifies.push([
-                [``],
-                comments.start,
-                comments.end,
-            ]);
-        }
-    }
     if (scriptSetupRanges.defineProps) {
         const { name, statement, callExp, typeArg } = scriptSetupRanges.defineProps;
         setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, scriptSetupRanges.withDefaults?.callExp ?? callExp, typeArg, name, `__VLS_props`, `__VLS_Props`));
@@ -405,7 +396,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
         for (const defineProp of scriptSetupRanges.defineProp) {
             const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
             if (defineProp.comments) {
-                yield (0, utils_1.generateSfcBlockSection)(scriptSetup, defineProp.comments.start, defineProp.comments.end, codeFeatures_1.codeFeatures.all);
+                yield scriptSetup.content.slice(defineProp.comments.start, defineProp.comments.end);
                 yield utils_1.newLine;
             }
             if (defineProp.isModel && !defineProp.name) {

package/lib/codegen/script/src.js

@@ -23,26 +23,7 @@ function* generateSrc(src) {
     yield `export * from `;
     yield* (0, utils_1.generateSfcBlockAttrValue)(src, text, {
         ...codeFeatures_1.codeFeatures.all,
-        navigation: text === src.text
-            ? true
-            : {
-                shouldRename: () => false,
-                resolveRenameEditText(newName) {
-                    if (newName.endsWith('.jsx') || newName.endsWith('.js')) {
-                        newName = newName.split('.').slice(0, -1).join('.');
-                    }
-                    if (src?.text.endsWith('.d.ts')) {
-                        newName = newName + '.d.ts';
-                    }
-                    else if (src?.text.endsWith('.ts')) {
-                        newName = newName + '.ts';
-                    }
-                    else if (src?.text.endsWith('.tsx')) {
-                        newName = newName + '.tsx';
-                    }
-                    return newName;
-                },
-            },
+        ...text === src.text ? codeFeatures_1.codeFeatures.navigation : codeFeatures_1.codeFeatures.navigationWithoutRename,
     });
     yield utils_1.endOfLine;
     yield `export { default } from '${text}'${utils_1.endOfLine}`;

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

@@ -1,4 +1,4 @@
 import type { Code } from '../../types';
 import type { ScriptCodegenContext } from './context';
-import { ScriptCodegenOptions } from './index';
+import type { ScriptCodegenOptions } from './index';
 export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

package/lib/codegen/script/styleModulesType.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleModulesType = generateStyleModulesType;
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-const index_1 = require("./index");
 const template_1 = require("./template");
 function* generateStyleModulesType(options, ctx) {
     const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
@@ -17,7 +17,7 @@ function* generateStyleModulesType(options, ctx) {
                 name,
                 'main',
                 offset + 1,
-                index_1.codeFeatures.all
+                codeFeatures_1.codeFeatures.all
             ];
         }
         else {

package/lib/codegen/script/template.js

@@ -15,9 +15,9 @@ function* generateTemplate(options, ctx) {
     ctx.generatedTemplate = true;
     const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
         scriptSetupBindingNames: new Set(),
-        edited: options.edited,
     });
     yield* generateTemplateCtx(options);
+    yield* generateTemplateElements();
     yield* generateTemplateComponents(options);
     yield* generateTemplateDirectives(options);
     yield* generateTemplateBody(options, templateCodegenCtx);
@@ -47,6 +47,9 @@ function* generateTemplateCtx(options) {
         yield `}${utils_1.endOfLine}`;
     }
 }
+function* generateTemplateElements() {
+    yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
+}
 function* generateTemplateComponents(options) {
     const types = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {

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

@@ -1,4 +1,4 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
+import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
 import { InlayHintInfo } from '../inlayHints';
 import type { TemplateCodegenOptions } from './index';
@@ -100,7 +100,18 @@ export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenCont
  * an error/diagnostic was encountered for a region of code covered by a `@vue-expect-error` directive,
  * and additionally how we use that to determine whether to propagate diagnostics back upward.
  */
-export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
+export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames'>): {
+    readonly currentInfo: {
+        ignoreError?: boolean;
+        expectError?: {
+            token: number;
+            node: CompilerDOM.CommentNode;
+        };
+        generic?: {
+            content: string;
+            offset: number;
+        };
+    };
     codeFeatures: {
         all: VueCodeInformation;
         none: VueCodeInformation;
@@ -120,6 +131,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
     };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
+    inVFor: boolean;
     slots: {
         name: string;
         offset?: number;
@@ -133,10 +145,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[];
     dollarVars: Set<string>;
     accessExternalVariables: Map<string, Set<number>>;
-    lastGenericComment: {
-        content: string;
-        offset: number;
-    } | undefined;
     blockConditions: string[];
     scopedClasses: {
         source: string;
@@ -150,22 +158,23 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     templateRefs: Map<string, {
         typeExp: string;
         offset: number;
-    }>;
+    }[]>;
     currentComponent: {
         ctxVar: string;
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];
     singleRootNodes: Set<CompilerDOM.ElementNode | null>;
+    addTemplateRef(name: string, typeExp: string, offset: number): void;
     accessExternalVariable(name: string, offset?: number): void;
-    hasLocalVariable: (name: string) => boolean;
-    addLocalVariable: (name: string) => void;
-    removeLocalVariable: (name: string) => void;
-    getInternalVariable: () => string;
-    getHoistVariable: (originalVar: string) => string;
-    generateHoistVariables: () => Generator<string, void, unknown>;
-    ignoreError: () => Generator<Code>;
-    expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
-    resetDirectiveComments: (endStr: string) => Generator<Code>;
-    generateAutoImportCompletion: () => Generator<Code>;
+    hasLocalVariable(name: string): boolean;
+    addLocalVariable(name: string): void;
+    removeLocalVariable(name: string): void;
+    getInternalVariable(): string;
+    getHoistVariable(originalVar: string): string;
+    generateHoistVariables(): Generator<string, void, unknown>;
+    generateConditionGuards(): Generator<string, void, unknown>;
+    generateAutoImportCompletion(): Generator<Code>;
+    enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
 };

package/lib/codegen/template/context.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplateCodegenContext = createTemplateCodegenContext;
+const CompilerDOM = require("@vue/compiler-dom");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
+const commentDirectiveRegex = /^<!--\s*@vue-(?<name>[-\w]+)\b(?<content>[\s\S]*)-->$/;
 /**
  * Creates and returns a Context object used for generating type-checkable TS code
  * from the template section of a .vue file.
@@ -102,13 +104,11 @@ const wrapWith_1 = require("../utils/wrapWith");
  * and additionally how we use that to determine whether to propagate diagnostics back upward.
  */
 function createTemplateCodegenContext(options) {
-    let ignoredError = false;
-    let expectErrorToken;
-    let lastGenericComment;
     let variableId = 0;
     function resolveCodeFeatures(features) {
-        if (features.verification) {
-            if (ignoredError) {
+        if (features.verification && stack.length) {
+            const data = stack[stack.length - 1];
+            if (data.ignoreError) {
                 // We are currently in a region of code covered by a @vue-ignore directive, so don't
                 // even bother performing any type-checking: set verification to false.
                 return {
@@ -116,17 +116,16 @@ function createTemplateCodegenContext(options) {
                     verification: false,
                 };
             }
-            if (expectErrorToken) {
+            if (data.expectError !== undefined) {
                 // We are currently in a region of code covered by a @vue-expect-error directive. We need to
                 // keep track of the number of errors encountered within this region so that we can know whether
                 // we will need to propagate an "unused ts-expect-error" diagnostic back to the original
                 // .vue file or not.
-                const token = expectErrorToken;
                 return {
                     ...features,
                     verification: {
                         shouldReport: () => {
-                            token.errors++;
+                            data.expectError.token++;
                             return false;
                         },
                     },
@@ -148,7 +147,12 @@ function createTemplateCodegenContext(options) {
     const bindingAttrLocs = [];
     const inheritedAttrVars = new Set();
     const templateRefs = new Map();
+    const stack = [];
+    const commentBuffer = [];
     return {
+        get currentInfo() {
+            return stack[stack.length - 1];
+        },
         codeFeatures: new Proxy(codeFeatures_1.codeFeatures, {
             get(target, key) {
                 const data = target[key];
@@ -156,11 +160,11 @@ function createTemplateCodegenContext(options) {
             },
         }),
         resolveCodeFeatures,
+        inVFor: false,
         slots,
         dynamicSlots,
         dollarVars,
         accessExternalVariables,
-        lastGenericComment,
         blockConditions,
         scopedClasses,
         emptyClassOffsets,
@@ -171,6 +175,13 @@ function createTemplateCodegenContext(options) {
         currentComponent: undefined,
         singleRootElTypes: [],
         singleRootNodes: new Set(),
+        addTemplateRef(name, typeExp, offset) {
+            let refs = templateRefs.get(name);
+            if (!refs) {
+                templateRefs.set(name, refs = []);
+            }
+            refs.push({ typeExp, offset });
+        },
         accessExternalVariable(name, offset) {
             let arr = accessExternalVariables.get(name);
             if (!arr) {
@@ -180,26 +191,26 @@ function createTemplateCodegenContext(options) {
                 arr.add(offset);
             }
         },
-        hasLocalVariable: (name) => {
+        hasLocalVariable(name) {
             return !!localVars.get(name);
         },
-        addLocalVariable: (name) => {
+        addLocalVariable(name) {
             localVars.set(name, (localVars.get(name) ?? 0) + 1);
         },
-        removeLocalVariable: (name) => {
+        removeLocalVariable(name) {
             localVars.set(name, localVars.get(name) - 1);
         },
-        getInternalVariable: () => {
+        getInternalVariable() {
             return `__VLS_${variableId++}`;
         },
-        getHoistVariable: (originalVar) => {
+        getHoistVariable(originalVar) {
             let name = hoistVars.get(originalVar);
             if (name === undefined) {
                 hoistVars.set(originalVar, name = `__VLS_${variableId++}`);
             }
             return name;
         },
-        generateHoistVariables: function* () {
+        *generateHoistVariables() {
             // trick to avoid TS 4081 (#5186)
             if (hoistVars.size) {
                 yield `// @ts-ignore${utils_1.newLine}`;
@@ -210,45 +221,12 @@ function createTemplateCodegenContext(options) {
                 yield utils_1.endOfLine;
             }
         },
-        ignoreError: function* () {
-            if (!ignoredError) {
-                ignoredError = true;
-                yield `// @vue-ignore start${utils_1.newLine}`;
+        *generateConditionGuards() {
+            for (const condition of blockConditions) {
+                yield `if (!${condition}) return${utils_1.endOfLine}`;
             }
         },
-        expectError: function* (prevNode) {
-            if (!expectErrorToken) {
-                expectErrorToken = {
-                    errors: 0,
-                    node: prevNode,
-                };
-                yield `// @vue-expect-error start${utils_1.newLine}`;
-            }
-        },
-        resetDirectiveComments: function* (endStr) {
-            if (expectErrorToken) {
-                const token = expectErrorToken;
-                yield* (0, wrapWith_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
-                    verification: {
-                        // If no errors/warnings/diagnostics were reported within the region of code covered
-                        // by the @vue-expect-error directive, then we should allow any `unused @ts-expect-error`
-                        // diagnostics to be reported upward.
-                        shouldReport: () => token.errors === 0,
-                    },
-                }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
-                yield `${utils_1.newLine}${utils_1.endOfLine}`;
-                expectErrorToken = undefined;
-                yield `// @vue-expect-error ${endStr}${utils_1.newLine}`;
-            }
-            if (ignoredError) {
-                ignoredError = false;
-                yield `// @vue-ignore ${endStr}${utils_1.newLine}`;
-            }
-        },
-        generateAutoImportCompletion: function* () {
-            if (!options.edited) {
-                return;
-            }
+        *generateAutoImportCompletion() {
             const all = [...accessExternalVariables.entries()];
             if (!all.some(([_, offsets]) => offsets.size)) {
                 return;
@@ -282,7 +260,65 @@ function createTemplateCodegenContext(options) {
                 offsets.clear();
             }
             yield `]${utils_1.endOfLine}`;
-        }
+        },
+        enter(node) {
+            if (node.type === CompilerDOM.NodeTypes.COMMENT) {
+                commentBuffer.push(node);
+                return false;
+            }
+            const data = {};
+            const comments = [...commentBuffer];
+            commentBuffer.length = 0;
+            for (const comment of comments) {
+                const match = comment.loc.source.match(commentDirectiveRegex);
+                if (match) {
+                    const { name, content } = match.groups;
+                    switch (name) {
+                        case 'skip': {
+                            return false;
+                        }
+                        case 'ignore': {
+                            data.ignoreError = true;
+                            break;
+                        }
+                        case 'expect-error': {
+                            data.expectError = {
+                                token: 0,
+                                node: comment,
+                            };
+                            break;
+                        }
+                        case 'generic': {
+                            const text = content.trim();
+                            if (text.startsWith('{') && text.endsWith('}')) {
+                                data.generic = {
+                                    content: text.slice(1, -1),
+                                    offset: comment.loc.start.offset + comment.loc.source.indexOf('{') + 1,
+                                };
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            stack.push(data);
+            return true;
+        },
+        *exit() {
+            const data = stack.pop();
+            commentBuffer.length = 0;
+            if (data.expectError !== undefined) {
+                yield* (0, wrapWith_1.wrapWith)(data.expectError.node.loc.start.offset, data.expectError.node.loc.end.offset, {
+                    verification: {
+                        // If no errors/warnings/diagnostics were reported within the region of code covered
+                        // by the @vue-expect-error directive, then we should allow any `unused @ts-expect-error`
+                        // diagnostics to be reported upward.
+                        shouldReport: () => data.expectError.token === 0,
+                    },
+                }, `// @ts-expect-error`);
+                yield `${utils_1.newLine}${utils_1.endOfLine}`;
+            }
+        },
     };
 }
 //# sourceMappingURL=context.js.map

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

@@ -2,5 +2,5 @@ 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 generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;
-export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;