@vue/language-core 2.1.6 → 2.1.8

package/lib/codegen/common.d.ts

@@ -6,7 +6,7 @@ export declare const combineLastMapping: VueCodeInformation;
 export declare const variableNameRegex: RegExp;
 export declare function conditionWrapWith(condition: boolean, startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
 export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
-export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[], includesRest?: boolean): string[];
-export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: ts.Identifier[], includesRest?: boolean): ts.Identifier[];
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

package/lib/codegen/common.js

@@ -33,33 +33,31 @@ function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
     }
     yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
 }
-function collectVars(ts, node, ast, results = [], includesRest = true) {
-    const identifiers = collectIdentifiers(ts, node, [], includesRest);
-    for (const id of identifiers) {
+function collectVars(ts, node, ast, results = []) {
+    const identifiers = collectIdentifiers(ts, node, []);
+    for (const [id] of identifiers) {
         results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
     }
     return results;
 }
-function collectIdentifiers(ts, node, results = [], includesRest = true) {
+function collectIdentifiers(ts, node, results = [], isRest = false) {
     if (ts.isIdentifier(node)) {
-        results.push(node);
+        results.push([node, isRest]);
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            if (includesRest || !el.dotDotDotToken) {
-                collectIdentifiers(ts, el.name, results, includesRest);
-            }
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
         for (const el of node.elements) {
             if (ts.isBindingElement(el)) {
-                collectIdentifiers(ts, el.name, results, includesRest);
+                collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
             }
         }
     }
     else {
-        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, includesRest));
+        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, false));
     }
     return results;
 }

package/lib/codegen/globalTypes.js

@@ -79,11 +79,18 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		>
 	>;
 	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+	type __VLS_PickFunctionalComponentCtx<T, K> = NonNullable<__VLS_PickNotAny<
+		'__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_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType(source: number): [number, number, number][];
 	function __VLS_getVForSourceType(source: string): [string, number, number][];
 	function __VLS_getVForSourceType<T extends any[]>(source: T): [
-		item: T[number],
+		item: ${(target >= 3 ? `import('${lib}').Reactive<T[number]>` :
+        target >= 2.7 ? `import('${lib}').UnwrapNestedRefs<T[number]>` :
+            `T[number]`)},
 		key: number,
 		index: number,
 	][];
@@ -107,9 +114,11 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 	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_directiveAsFunction<T extends import('${lib}').Directive>(dir: T): T extends (...args: any) => any
-		? T | __VLS_unknownDirective
-		: NonNullable<(T & Record<string, __VLS_unknownDirective>)['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>;
+	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
+			? T
+			: __VLS_unknownDirective;
 	function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
 	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
 	function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
@@ -125,10 +134,6 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		: (_: {}${strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${strictTemplates ? '' : ' & Record<string, unknown>'} } };
 	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
-	function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): NonNullable<__VLS_PickNotAny<
-		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
-		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
-	>>;
 	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
 	function __VLS_tryAsConstant<const T>(t: T): T;
 }

package/lib/codegen/inlayHints.d.ts

@@ -0,0 +1,11 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+export interface InlayHintInfo {
+    blockName: string;
+    offset: number;
+    setting: string;
+    label: string;
+    tooltip?: string;
+    paddingRight?: boolean;
+    paddingLeft?: boolean;
+}
+export declare function createVBindShorthandInlayHintInfo(loc: CompilerDOM.SourceLocation, variableName: string): InlayHintInfo;

package/lib/codegen/inlayHints.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVBindShorthandInlayHintInfo = createVBindShorthandInlayHintInfo;
+function createVBindShorthandInlayHintInfo(loc, variableName) {
+    return {
+        blockName: 'template',
+        offset: loc.end.offset,
+        setting: 'vue.inlayHints.vBindShorthand',
+        label: `="${variableName}"`,
+        tooltip: [
+            `This is a shorthand for \`${loc.source}="${variableName}"\`.`,
+            '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'),
+    };
+}
+//# sourceMappingURL=inlayHints.js.map

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

@@ -4,5 +4,5 @@ import type { ScriptCodegenContext } from './context';
 import { ScriptCodegenOptions } from './index';
 export declare function generateComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
 export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
-export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
 export declare function generatePropsOption(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges, hasEmitsOption: boolean, inheritAttrs: boolean): Generator<Code>;

package/lib/codegen/script/component.js

@@ -26,7 +26,7 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     yield `}${common_1.endOfLine}`;
     yield `},${common_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
-        const emitOptionCodes = [...generateEmitsOption(options, scriptSetup, scriptSetupRanges)];
+        const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
         for (const code of emitOptionCodes) {
             yield code;
         }
@@ -39,6 +39,9 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     if (options.vueCompilerOptions.target >= 3.5 && scriptSetupRanges.templateRefs.length) {
         yield `__typeRefs: {} as __VLS_TemplateResult['refs'],${common_1.newLine}`;
     }
+    if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.singleRootElType) {
+        yield `__typeEl: {} as __VLS_TemplateResult['rootEl'],${common_1.newLine}`;
+    }
     yield `})`;
 }
 function* generateComponentSetupReturns(scriptSetupRanges) {
@@ -53,12 +56,12 @@ function* generateComponentSetupReturns(scriptSetupRanges) {
         yield `$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
     }
 }
-function* generateEmitsOption(options, scriptSetup, scriptSetupRanges) {
+function* generateEmitsOption(options, scriptSetupRanges) {
     const codes = [];
     if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
         codes.push({
-            optionExp: `{} as __VLS_NormalizeEmits<__VLS_ModelEmitsType>`,
-            typeOptionType: `__VLS_ModelEmitsType`,
+            optionExp: `{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`,
+            typeOptionType: `__VLS_ModelEmit`,
         });
     }
     if (scriptSetupRanges.emits.define) {
@@ -66,7 +69,7 @@ function* generateEmitsOption(options, scriptSetup, scriptSetupRanges) {
         codes.push({
             optionExp: `{} as __VLS_NormalizeEmits<typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}>`,
             typeOptionType: typeArg && !hasUnionTypeArg
-                ? scriptSetup.content.slice(typeArg.start, typeArg.end)
+                ? `__VLS_Emit`
                 : undefined,
         });
     }

package/lib/codegen/script/componentSelf.js

@@ -41,7 +41,7 @@ function* generateComponentSelf(options, ctx, templateCodegenCtx) {
         yield `}${common_1.endOfLine}`; // return {
         yield `},${common_1.newLine}`; // setup() {
         if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
-            const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.sfc.scriptSetup, options.scriptSetupRanges)];
+            const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.scriptSetupRanges)];
             for (const code of emitOptionCodes) {
                 yield code;
             }

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

@@ -1,4 +1,4 @@
-import { InlayHintInfo } from '../types';
+import { InlayHintInfo } from '../inlayHints';
 import type { ScriptCodegenOptions } from './index';
 export interface HelperType {
     name: string;

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

@@ -30,3 +30,4 @@ export interface ScriptCodegenOptions {
     linkedCodeMappings: Mapping[];
 }
 export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;
+export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string): Generator<Code>;

package/lib/codegen/script/index.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codeFeatures = void 0;
 exports.generateScript = generateScript;
+exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
 const common_1 = require("../common");
 const globalTypes_1 = require("../globalTypes");
-const context_1 = require("./context");
 const componentSelf_1 = require("./componentSelf");
+const context_1 = require("./context");
 const scriptSetup_1 = require("./scriptSetup");
 const src_1 = require("./src");
 const styleModulesType_1 = require("./styleModulesType");
@@ -35,7 +36,13 @@ exports.codeFeatures = {
 function* generateScript(options) {
     const ctx = (0, context_1.createScriptCodegenContext)(options);
     if (options.vueCompilerOptions.__setupedGlobalTypes) {
-        yield `/// <reference types=".vue-global-types/${options.vueCompilerOptions.lib}_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${common_1.newLine}`;
+        const globalTypes = options.vueCompilerOptions.__setupedGlobalTypes;
+        if (typeof globalTypes === 'object') {
+            yield `/// <reference types="${globalTypes.absolutePath}" />${common_1.newLine}`;
+        }
+        else {
+            yield `/// <reference types=".vue-global-types/${options.vueCompilerOptions.lib}_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${common_1.newLine}`;
+        }
     }
     else {
         yield `/* placeholder */`;
@@ -57,6 +64,7 @@ function* generateScript(options) {
             }
             else {
                 yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+                yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/both.vue');
                 yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
             }
         }
@@ -92,10 +100,10 @@ function* generateScript(options) {
             }
             else {
                 yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, exports.codeFeatures.all);
-                yield `__VLS_template = () => {`;
-                const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx, true);
+                yield `__VLS_template = () => {${common_1.newLine}`;
+                const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
                 yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
-                yield `},${common_1.newLine}`;
+                yield `}${common_1.endOfLine}`;
                 yield (0, common_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, exports.codeFeatures.all);
             }
         }
@@ -108,15 +116,15 @@ function* generateScript(options) {
         yield* generateDefineProp(options, options.sfc.scriptSetup);
         yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
     }
-    yield `;`;
+    if (options.sfc.script) {
+        yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/script.vue');
+    }
     if (options.sfc.scriptSetup) {
-        // #4569
-        yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
+        yield* generateScriptSectionPartiallyEnding(options.sfc.scriptSetup.name, options.sfc.scriptSetup.content.length, '#4569/main.vue');
     }
-    yield common_1.newLine;
     if (!ctx.generatedTemplate) {
         yield `function __VLS_template() {${common_1.newLine}`;
-        const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx, false);
+        const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
         yield `}${common_1.endOfLine}`;
         yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
     }
@@ -134,6 +142,11 @@ function* generateScript(options) {
     }
     return ctx;
 }
+function* generateScriptSectionPartiallyEnding(source, end, mark) {
+    yield `;`;
+    yield ['', source, end, exports.codeFeatures.verification];
+    yield `/* PartiallyEnd: ${mark} */${common_1.newLine}`;
+}
 function* generateDefineProp(options, scriptSetup) {
     const definePropProposalA = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
     const definePropProposalB = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';

package/lib/codegen/script/scriptSetup.js

@@ -4,8 +4,8 @@ exports.generateScriptSetupImports = generateScriptSetupImports;
 exports.generateScriptSetup = generateScriptSetup;
 const common_1 = require("../common");
 const component_1 = require("./component");
-const index_1 = require("./index");
 const componentSelf_1 = require("./componentSelf");
+const index_1 = require("./index");
 const template_1 = require("./template");
 function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
     yield [
@@ -52,10 +52,10 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
             emitTypes.push(`typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}`);
         }
         if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
-            emitTypes.push(`__VLS_ModelEmitsType`);
+            emitTypes.push(`typeof __VLS_modelEmit`);
         }
         yield `		return {} as {${common_1.newLine}`
-            + `			props: ${ctx.localTypes.PrettifyLocal}<typeof __VLS_functionalComponentProps & __VLS_PublicProps> & __VLS_BuiltInPublicProps,${common_1.newLine}`
+            + `			props: ${ctx.localTypes.PrettifyLocal}<typeof __VLS_functionalComponentProps & __VLS_TemplateResult['attrs'] & __VLS_PublicProps> & __VLS_BuiltInPublicProps,${common_1.newLine}`
             + `			expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,${common_1.newLine}`
             + `			attrs: any,${common_1.newLine}`
             + `			slots: __VLS_TemplateResult['slots'],${common_1.newLine}`
@@ -106,45 +106,8 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     }
     ctx.scriptSetupGeneratedOffset = options.getGeneratedLength() - scriptSetupRanges.importSectionEndOffset;
     let setupCodeModifies = [];
-    const propsRange = scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define;
-    if (propsRange && scriptSetupRanges.props.define) {
-        const statement = scriptSetupRanges.props.define.statement;
-        if (scriptSetupRanges.props.define.typeArg) {
-            setupCodeModifies.push([[
-                    `let __VLS_typeProps!: `,
-                    (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end, index_1.codeFeatures.all),
-                    common_1.endOfLine,
-                ], statement.start, statement.start]);
-            setupCodeModifies.push([[`typeof __VLS_typeProps`], scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end]);
-        }
-        if (!scriptSetupRanges.props.name) {
-            if (statement.start === propsRange.start && statement.end === propsRange.end) {
-                setupCodeModifies.push([[`const __VLS_props = `], propsRange.start, propsRange.start]);
-            }
-            else {
-                if (scriptSetupRanges.props.define.typeArg) {
-                    setupCodeModifies.push([[
-                            `const __VLS_props = `,
-                            (0, common_1.generateSfcBlockSection)(scriptSetup, propsRange.start, scriptSetupRanges.props.define.typeArg.start, index_1.codeFeatures.all),
-                        ], statement.start, scriptSetupRanges.props.define.typeArg.start]);
-                    setupCodeModifies.push([[
-                            (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.typeArg.end, propsRange.end, index_1.codeFeatures.all),
-                            `${common_1.endOfLine}`,
-                            (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, propsRange.start, index_1.codeFeatures.all),
-                            `__VLS_props`,
-                        ], scriptSetupRanges.props.define.typeArg.end, propsRange.end]);
-                }
-                else {
-                    setupCodeModifies.push([[
-                            `const __VLS_props = `,
-                            (0, common_1.generateSfcBlockSection)(scriptSetup, propsRange.start, propsRange.end, index_1.codeFeatures.all),
-                            `${common_1.endOfLine}`,
-                            (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, propsRange.start, index_1.codeFeatures.all),
-                            `__VLS_props`,
-                        ], statement.start, propsRange.end]);
-                }
-            }
-        }
+    if (scriptSetupRanges.props.define) {
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, scriptSetupRanges.props.name, scriptSetupRanges.props.define, scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define, '__VLS_props', '__VLS_Props'));
     }
     if (scriptSetupRanges.slots.define) {
         if (scriptSetupRanges.slots.isObjectBindingPattern) {
@@ -158,8 +121,8 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
             setupCodeModifies.push([[`const __VLS_slots = `], scriptSetupRanges.slots.define.start, scriptSetupRanges.slots.define.start]);
         }
     }
-    if (scriptSetupRanges.emits.define && !scriptSetupRanges.emits.name) {
-        setupCodeModifies.push([[`const __VLS_emit = `], scriptSetupRanges.emits.define.start, scriptSetupRanges.emits.define.start]);
+    if (scriptSetupRanges.emits.define) {
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, scriptSetupRanges.emits.name, scriptSetupRanges.emits.define, scriptSetupRanges.emits.define, '__VLS_emit', '__VLS_Emit'));
     }
     if (scriptSetupRanges.expose.define) {
         if (scriptSetupRanges.expose.define?.typeArg) {
@@ -193,66 +156,67 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
         }
     }
     if (scriptSetupRanges.cssModules.length) {
-        for (const { exp, arg } of scriptSetupRanges.cssModules) {
-            if (arg) {
-                setupCodeModifies.push([
-                    [
-                        ` as Omit<__VLS_StyleModules, '$style'>[`,
-                        (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.all),
-                        `]`
-                    ],
-                    exp.end,
-                    exp.end
-                ]);
-            }
-            else {
-                setupCodeModifies.push([
-                    [
-                        ` as __VLS_StyleModules[`,
-                        ['', scriptSetup.name, exp.start, index_1.codeFeatures.verification],
-                        `'$style'`,
-                        ['', scriptSetup.name, exp.end, index_1.codeFeatures.verification],
-                        `]`
-                    ],
-                    exp.end,
-                    exp.end
-                ]);
-            }
+        for (const { define: { arg, exp } } of scriptSetupRanges.cssModules) {
+            setupCodeModifies.push([
+                arg ? [
+                    ` as Omit<__VLS_StyleModules, '$style'>[`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.all),
+                    `]`
+                ] : [
+                    ` as __VLS_StyleModules[`,
+                    ['', scriptSetup.name, exp.start, index_1.codeFeatures.verification],
+                    `'$style'`,
+                    ['', scriptSetup.name, exp.end, index_1.codeFeatures.verification],
+                    `]`
+                ],
+                exp.end,
+                exp.end
+            ]);
         }
     }
+    const isTs = options.lang !== 'js' && options.lang !== 'jsx';
     for (const { define } of scriptSetupRanges.templateRefs) {
-        if (define?.arg) {
+        if (!define?.arg) {
+            continue;
+        }
+        if (isTs) {
             setupCodeModifies.push([
                 [
                     `<__VLS_TemplateResult['refs'][`,
                     (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.navigation),
                     `], keyof __VLS_TemplateResult['refs']>`
                 ],
-                define.arg.start - 1,
-                define.arg.start - 1
+                define.exp.end,
+                define.exp.end
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`(`],
+                define.start,
+                define.start
+            ], [
+                [
+                    ` as __VLS_UseTemplateRef<__VLS_TemplateResult['refs'][`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.navigation),
+                    `]>)`
+                ],
+                define.end,
+                define.end
             ]);
         }
     }
     setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
-    if (setupCodeModifies.length) {
-        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.importSectionEndOffset, setupCodeModifies[0][1], index_1.codeFeatures.all);
-        while (setupCodeModifies.length) {
-            const [codes, _start, end] = setupCodeModifies.shift();
-            for (const code of codes) {
-                yield code;
-            }
-            if (setupCodeModifies.length) {
-                const nextStart = setupCodeModifies[0][1];
-                yield (0, common_1.generateSfcBlockSection)(scriptSetup, end, nextStart, index_1.codeFeatures.all);
-            }
-            else {
-                yield (0, common_1.generateSfcBlockSection)(scriptSetup, end, scriptSetup.content.length, index_1.codeFeatures.all);
-            }
+    let nextStart = scriptSetupRanges.importSectionEndOffset;
+    for (const [codes, start, end] of setupCodeModifies) {
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, nextStart, start, index_1.codeFeatures.all);
+        for (const code of codes) {
+            yield code;
         }
+        nextStart = end;
     }
-    else {
-        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.importSectionEndOffset, scriptSetup.content.length, index_1.codeFeatures.all);
-    }
+    yield (0, common_1.generateSfcBlockSection)(scriptSetup, nextStart, scriptSetup.content.length, index_1.codeFeatures.all);
+    yield* (0, index_1.generateScriptSectionPartiallyEnding)(scriptSetup.name, scriptSetup.content.length, '#3632/scriptSetup.vue');
     if (scriptSetupRanges.props.define?.typeArg && scriptSetupRanges.props.withDefaults?.arg) {
         // fix https://github.com/vuejs/language-tools/issues/1187
         yield `const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`;
@@ -260,9 +224,9 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
         yield `)${common_1.endOfLine}`;
     }
     yield* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors);
-    yield* generateModelEmits(options, scriptSetup, scriptSetupRanges);
+    yield* generateModelEmit(scriptSetup, scriptSetupRanges);
     yield `function __VLS_template() {${common_1.newLine}`;
-    const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx, false);
+    const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
     yield `}${common_1.endOfLine}`;
     yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
     yield `type __VLS_TemplateResult = ReturnType<typeof __VLS_template>${common_1.endOfLine}`;
@@ -281,6 +245,43 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
         }
     }
 }
+function* generateDefineWithType(scriptSetup, name, define, expression, defaultName, typeName) {
+    const { statement, typeArg } = define;
+    if (typeArg) {
+        yield [[
+                `type ${typeName} = `,
+                (0, common_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, index_1.codeFeatures.all),
+                common_1.endOfLine,
+            ], statement.start, statement.start];
+        yield [[typeName], typeArg.start, typeArg.end];
+    }
+    if (!name) {
+        if (statement.start === expression.start && statement.end === expression.end) {
+            yield [[`const ${defaultName} = `], expression.start, expression.start];
+        }
+        else if (typeArg) {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, expression.start, typeArg.start, index_1.codeFeatures.all)
+                ], statement.start, typeArg.start];
+            yield [[
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, typeArg.end, expression.end, index_1.codeFeatures.all),
+                    common_1.endOfLine,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, expression.start, index_1.codeFeatures.all),
+                    defaultName
+                ], typeArg.end, expression.end];
+        }
+        else {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, expression.start, expression.end, index_1.codeFeatures.all),
+                    common_1.endOfLine,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, expression.start, index_1.codeFeatures.all),
+                    defaultName
+                ], statement.start, expression.end];
+        }
+    }
+}
 function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors) {
     yield `const __VLS_fnComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
     if (scriptSetupRanges.props.define?.arg) {
@@ -288,7 +289,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
         yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end, index_1.codeFeatures.navigation);
         yield `,${common_1.newLine}`;
     }
-    yield* (0, component_1.generateEmitsOption)(options, scriptSetup, scriptSetupRanges);
+    yield* (0, component_1.generateEmitsOption)(options, scriptSetupRanges);
     yield `})${common_1.endOfLine}`;
     yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
         ? `import('${options.vueCompilerOptions.lib}').PublicProps;`
@@ -374,35 +375,25 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             yield ` & `;
         }
         ctx.generatedPropsType = true;
-        yield `typeof __VLS_typeProps`;
+        yield `__VLS_Props`;
     }
     if (!ctx.generatedPropsType) {
         yield `{}`;
     }
     yield common_1.endOfLine;
 }
-function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
+function* generateModelEmit(scriptSetup, scriptSetupRanges) {
     const defineModels = scriptSetupRanges.defineProp.filter(p => p.isModel);
     if (defineModels.length) {
-        const generateDefineModels = function* () {
-            for (const defineModel of defineModels) {
-                const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
-                yield `'update:${propName}': [${propName}:`;
-                yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
-                yield `]${common_1.endOfLine}`;
-            }
-        };
-        if (options.vueCompilerOptions.target >= 3.5) {
-            yield `type __VLS_ModelEmitsType = {${common_1.newLine}`;
-            yield* generateDefineModels();
-            yield `}${common_1.endOfLine}`;
-        }
-        else {
-            yield `const __VLS_modelEmitsType = (await import('${options.vueCompilerOptions.lib}')).defineEmits<{${common_1.newLine}`;
-            yield* generateDefineModels();
-            yield `}>()${common_1.endOfLine}`;
-            yield `type __VLS_ModelEmitsType = typeof __VLS_modelEmitsType${common_1.endOfLine}`;
+        yield `type __VLS_ModelEmit = {${common_1.newLine}`;
+        for (const defineModel of defineModels) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
+            yield `'update:${propName}': [value:`;
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
+            yield `]${common_1.endOfLine}`;
         }
+        yield `}${common_1.endOfLine}`;
+        yield `const __VLS_modelEmit = defineEmits<__VLS_ModelEmit>()${common_1.endOfLine}`;
     }
 }
 function* generateDefinePropType(scriptSetup, propName, localName, defineProp) {

package/lib/codegen/script/styleModulesType.js

@@ -5,13 +5,12 @@ const index_1 = require("./index");
 const template_1 = require("./template");
 const common_1 = require("../common");
 function* generateStyleModulesType(options, ctx) {
-    const styles = options.sfc.styles.filter(style => style.module);
+    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
     if (!styles.length) {
         return;
     }
     yield `type __VLS_StyleModules = {${common_1.newLine}`;
-    for (let i = 0; i < styles.length; i++) {
-        const style = styles[i];
+    for (const [style, i] of styles) {
         const { name, offset } = style.module;
         if (offset) {
             yield [
@@ -30,7 +29,6 @@ function* generateStyleModulesType(options, ctx) {
         }
         yield `>${common_1.endOfLine}`;
     }
-    yield `}`;
-    yield common_1.endOfLine;
+    yield `}${common_1.endOfLine}`;
 }
 //# sourceMappingURL=styleModulesType.js.map

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

@@ -3,6 +3,6 @@ import { TemplateCodegenContext } from '../template/context';
 import type { ScriptCodegenContext } from './context';
 import { type ScriptCodegenOptions } from './index';
 export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
-export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, isClassComponent: boolean): Generator<Code, TemplateCodegenContext>;
+export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
 export declare function generateCssClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string, optional: boolean): Generator<Code>;
 export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;