@vue/language-core 2.0.28 → 2.1.0

package/index.d.ts

@@ -1,13 +1,14 @@
+export * from './lib/codegen/globalTypes';
 export * from './lib/codegen/template';
 export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
-export * from './lib/virtualFile/vueFile';
 export * from './lib/types';
-export * from './lib/utils/ts';
 export * from './lib/utils/parseSfc';
+export * from './lib/utils/ts';
+export * from './lib/virtualFile/vueFile';
 export * as scriptRanges from './lib/parsers/scriptRanges';
-export * from './lib/utils/shared';
 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

@@ -15,17 +15,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = exports.scriptRanges = void 0;
+__exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
-__exportStar(require("./lib/virtualFile/vueFile"), exports);
 __exportStar(require("./lib/types"), exports);
-__exportStar(require("./lib/utils/ts"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
+__exportStar(require("./lib/utils/ts"), exports);
+__exportStar(require("./lib/virtualFile/vueFile"), exports);
 exports.scriptRanges = require("./lib/parsers/scriptRanges");
-__exportStar(require("./lib/utils/shared"), 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/common.d.ts

@@ -6,6 +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, result: string[]): void;
+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 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

@@ -4,6 +4,7 @@ exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exp
 exports.conditionWrapWith = conditionWrapWith;
 exports.wrapWith = wrapWith;
 exports.collectVars = collectVars;
+exports.collectIdentifiers = collectIdentifiers;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
@@ -32,25 +33,35 @@ function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
     }
     yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
 }
-function collectVars(ts, node, ast, result) {
+function collectVars(ts, node, ast, results = [], includesRest = true) {
+    const identifiers = collectIdentifiers(ts, node, [], includesRest);
+    for (const id of identifiers) {
+        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+    }
+    return results;
+}
+function collectIdentifiers(ts, node, results = [], includesRest = true) {
     if (ts.isIdentifier(node)) {
-        result.push((0, scriptSetupRanges_1.getNodeText)(ts, node, ast));
+        results.push(node);
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            collectVars(ts, el.name, ast, result);
+            if (includesRest || !el.dotDotDotToken) {
+                collectIdentifiers(ts, el.name, results, includesRest);
+            }
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
         for (const el of node.elements) {
             if (ts.isBindingElement(el)) {
-                collectVars(ts, el.name, ast, result);
+                collectIdentifiers(ts, el.name, results, includesRest);
             }
         }
     }
     else {
-        ts.forEachChild(node, node => collectVars(ts, node, ast, result));
+        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, includesRest));
     }
+    return results;
 }
 function createTsAst(ts, astHolder, text) {
     if (astHolder.__volar_ast_text !== text) {

package/lib/codegen/globalTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;

package/lib/codegen/globalTypes.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGlobalTypes = generateGlobalTypes;
+const shared_1 = require("../utils/shared");
+function generateGlobalTypes(lib, target, strictTemplates) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${strictTemplates ? '' : ' & Record<string, unknown>'}`;
+    return `
+const __VLS_globalComponents = { ...{} as import('${lib}').GlobalComponents };
+
+declare const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+declare const __VLS_directiveBindingRestFields = { instance: null, oldValue: null, modifiers: null as any, dir: null as any };
+
+type __VLS_IntrinsicElements = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements;`
+        : `globalThis.JSX.IntrinsicElements;`)}
+type __VLS_Element = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.Element;`
+        : `globalThis.JSX.Element;`)}
+type __VLS_GlobalComponents = ${(target >= 3.5
+        ? `void extends typeof __VLS_globalComponents ? {} : typeof __VLS_globalComponents;`
+        : `(void extends typeof __VLS_globalComponents ? {} : typeof __VLS_globalComponents) & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`)}
+type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+type __VLS_unknownDirective = (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
+type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =
+	N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N1] } :
+	N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N2] } :
+	N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N3] } :
+	N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N1] } :
+	N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N2] } :
+	N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N3] } :
+	${strictTemplates ? '{}' : '{ [K in N0]: unknown }'}
+type __VLS_FunctionalComponentProps<T, K> =
+	'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+	: T extends (props: infer P, ...args: any) => any ? P :
+	{};
+type __VLS_IsFunction<T, K> = K extends keyof T
+	? __VLS_IsAny<T[K]> extends false
+	? unknown extends T[K]
+	? false
+	: true
+	: false
+	: false;
+// fix https://github.com/vuejs/language-tools/issues/926
+type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R
+	? U extends T
+	? never
+	: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
+	: never;
+type __VLS_OverloadUnion<T> = Exclude<
+	__VLS_OverloadUnionInner<(() => never) & T>,
+	T extends () => never ? never : () => never
+>;
+type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
+	? F extends (event: infer E, ...args: infer A) => any
+	? { [K in E & string]: (...args: A) => void; }
+	: never
+	: never;
+type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
+	__VLS_UnionToIntersection<
+		__VLS_ConstructorOverloads<T> & {
+			[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+		}
+	>
+>;
+type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+
+declare function __VLS_getVForSourceType(source: number): [number, number, number][];
+declare function __VLS_getVForSourceType(source: string): [string, number, number][];
+declare function __VLS_getVForSourceType<T extends any[]>(source: T): [
+	item: T[number],
+	key: number,
+	index: number,
+][];
+declare function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+	item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
+	key: number,
+	index: undefined,
+][];
+// #3845
+declare function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+	item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
+	key: number,
+	index: undefined,
+][];
+declare function __VLS_getVForSourceType<T>(source: T): [
+	item: T[keyof T],
+	key: keyof T,
+	index: number,
+][];
+// @ts-ignore
+declare function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+// @ts-ignore
+declare function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+declare 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']>;
+declare function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+declare function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+declare function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
+declare function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+	T extends new (...args: any) => any
+	? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & { __ctx?: {
+		attrs?: any,
+		slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : any,
+		emit?: K extends { $emit: infer Emit } ? Emit : any
+	} & { props?: ${fnPropsType}; expose?(exposed: K): void; } }
+	: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+	: T extends (...args: any) => any ? T
+	: (_: {}${strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${strictTemplates ? '' : ' & Record<string, unknown>'} } };
+declare function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+declare function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+declare 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
+>>;
+declare function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+declare function __VLS_tryAsConstant<const T>(t: T): T;
+`;
+}
+;
+//# sourceMappingURL=globalTypes.js.map

package/lib/codegen/localTypes.d.ts

@@ -0,0 +1,14 @@
+import type * as ts from 'typescript';
+import { VueCompilerOptions } from '../types';
+export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+    generate: (names: string[]) => Generator<string, void, unknown>;
+    getUsedNames(): Set<string>;
+    readonly PrettifyLocal: string;
+    readonly OmitKeepDiscriminatedUnion: string;
+    readonly WithDefaults: string;
+    readonly WithTemplateSlots: string;
+    readonly PropsChildren: string;
+    readonly TypePropsToOption: string;
+    readonly OmitIndexSignature: string;
+    readonly PickRefsExpose: string;
+};

package/lib/codegen/localTypes.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalTypesGenerator = getLocalTypesGenerator;
+const shared_1 = require("../utils/shared");
+const common_1 = require("./common");
+function getLocalTypesGenerator(compilerOptions, vueCompilerOptions) {
+    const used = new Set();
+    const OmitKeepDiscriminatedUnion = defineHelper(`__VLS_OmitKeepDiscriminatedUnion`, () => `
+type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
+	? Pick<T, Exclude<keyof T, K>>
+	: never;
+`.trimStart());
+    const WithDefaults = defineHelper(`__VLS_WithDefaults`, () => `
+type __VLS_WithDefaults<P, D> = {
+	[K in keyof Pick<P, keyof P>]: K extends keyof D
+		? ${PrettifyLocal.name}<P[K] & { default: D[K]}>
+		: P[K]
+};
+`.trimStart());
+    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${common_1.endOfLine}`);
+    const WithTemplateSlots = defineHelper(`__VLS_WithTemplateSlots`, () => `
+type __VLS_WithTemplateSlots<T, S> = T & {
+	new(): {
+		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
+		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
+	}
+};
+`.trimStart());
+    const PropsChildren = defineHelper(`__VLS_PropsChildren`, () => `
+type __VLS_PropsChildren<S> = {
+	[K in keyof (
+		boolean extends (
+			// @ts-ignore
+			JSX.ElementChildrenAttribute extends never
+				? true
+				: false
+		)
+			? never
+			// @ts-ignore
+			: JSX.ElementChildrenAttribute
+	)]?: S;
+};
+`.trimStart());
+    const TypePropsToOption = defineHelper(`__VLS_TypePropsToOption`, () => compilerOptions.exactOptionalPropertyTypes ?
+        `
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<T[K]> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart() :
+        `
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart());
+    const OmitIndexSignature = defineHelper(`__VLS_OmitIndexSignature`, () => `type __VLS_OmitIndexSignature<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K]; }${common_1.endOfLine}`);
+    const PickRefsExpose = defineHelper(`__VLS_PickRefsExpose`, () => `
+type __VLS_PickRefsExpose<T> = T extends object
+	? { [K in keyof T]: (T[K] extends any[]
+	? Parameters<T[K][0]['expose']>[0][]
+	: T[K] extends { expose?: (exposed: infer E) => void }
+	? E
+	: T[K]) | null }
+	: never;
+`.trimStart());
+    const helpers = {
+        [PrettifyLocal.name]: PrettifyLocal,
+        [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
+        [WithDefaults.name]: WithDefaults,
+        [WithTemplateSlots.name]: WithTemplateSlots,
+        [PropsChildren.name]: PropsChildren,
+        [TypePropsToOption.name]: TypePropsToOption,
+        [OmitIndexSignature.name]: OmitIndexSignature,
+        [PickRefsExpose.name]: PickRefsExpose,
+    };
+    used.clear();
+    return {
+        generate,
+        getUsedNames() {
+            return used;
+        },
+        get PrettifyLocal() { return PrettifyLocal.name; },
+        get OmitKeepDiscriminatedUnion() { return OmitKeepDiscriminatedUnion.name; },
+        get WithDefaults() { return WithDefaults.name; },
+        get WithTemplateSlots() { return WithTemplateSlots.name; },
+        get PropsChildren() { return PropsChildren.name; },
+        get TypePropsToOption() { return TypePropsToOption.name; },
+        get OmitIndexSignature() { return OmitIndexSignature.name; },
+        get PickRefsExpose() { return PickRefsExpose.name; },
+    };
+    function* generate(names) {
+        const generated = new Set();
+        while (names.length) {
+            used.clear();
+            for (const name of names) {
+                if (generated.has(name)) {
+                    continue;
+                }
+                const helper = helpers[name];
+                yield helper.generate();
+                generated.add(name);
+            }
+            names = [...used].filter(name => !generated.has(name));
+        }
+    }
+    function defineHelper(name, generate) {
+        return {
+            get name() {
+                used.add(name);
+                return name;
+            },
+            generate,
+        };
+    }
+}
+//# sourceMappingURL=localTypes.js.map

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

@@ -1,11 +1,8 @@
-import type { ScriptRanges } from '../../parsers/scriptRanges';
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc } from '../../types';
 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 generateScriptOptions(script: NonNullable<Sfc['script']>, scriptRanges: ScriptRanges): Generator<Code>;
-export declare function generateScriptSetupOptions(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
-export declare function generatePropsOption(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code, void, unknown>;
 export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetup: NonNullable<Sfc['scriptSetup']>, 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

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateComponent = generateComponent;
 exports.generateComponentSetupReturns = generateComponentSetupReturns;
-exports.generateScriptOptions = generateScriptOptions;
-exports.generateScriptSetupOptions = generateScriptSetupOptions;
-exports.generatePropsOption = generatePropsOption;
 exports.generateEmitsOption = generateEmitsOption;
+exports.generatePropsOption = generatePropsOption;
 const common_1 = require("../common");
 const index_1 = require("./index");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
@@ -28,10 +26,18 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     yield `}${common_1.endOfLine}`;
     yield `},${common_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
-        yield* generateScriptSetupOptions(options, ctx, scriptSetup, scriptSetupRanges);
+        const emitOptionCodes = [...generateEmitsOption(options, scriptSetup, scriptSetupRanges)];
+        for (const code of emitOptionCodes) {
+            yield code;
+        }
+        yield* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, !!emitOptionCodes.length, true);
     }
-    if (options.sfc.script && options.scriptRanges) {
-        yield* generateScriptOptions(options.sfc.script, options.scriptRanges);
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
+        const { args } = options.scriptRanges.exportDefault;
+        yield (0, common_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && scriptSetupRanges.templateRefs.length) {
+        yield `__typeRefs: {} as __VLS_Refs,${common_1.newLine}`;
     }
     yield `})`;
 }
@@ -47,78 +53,121 @@ function* generateComponentSetupReturns(scriptSetupRanges) {
         yield `$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
     }
 }
-function* generateScriptOptions(script, scriptRanges) {
-    if (scriptRanges.exportDefault?.args) {
-        yield (0, common_1.generateSfcBlockSection)(script, scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1, index_1.codeFeatures.all);
+function* generateEmitsOption(options, scriptSetup, scriptSetupRanges) {
+    const codes = [];
+    if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<__VLS_ModelEmitsType>`,
+            typeOptionType: `__VLS_ModelEmitsType`,
+        });
     }
-}
-function* generateScriptSetupOptions(options, ctx, scriptSetup, scriptSetupRanges) {
-    yield* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges);
-    yield* generateEmitsOption(options, scriptSetup, scriptSetupRanges);
-}
-function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges) {
-    if (options.vueCompilerOptions.target >= 3.5 && ctx.generatedPropsType) {
-        yield `__typeProps: {} as __VLS_PublicProps,${common_1.newLine}`;
-    }
-    if (options.vueCompilerOptions.target < 3.5 || !ctx.generatedPropsType || scriptSetupRanges.props.withDefaults) {
-        const codegens = [];
-        if (ctx.generatedPropsType) {
-            codegens.push(function* () {
-                yield `{} as `;
-                if (scriptSetupRanges.props.withDefaults?.arg) {
-                    yield `${ctx.helperTypes.WithDefaults.name}<`;
-                }
-                yield `${ctx.helperTypes.TypePropsToOption.name}<`;
-                yield `__VLS_PublicProps>`;
-                if (scriptSetupRanges.props.withDefaults?.arg) {
-                    yield `, typeof __VLS_withDefaultsArg>`;
-                }
-            });
-        }
-        if (scriptSetupRanges.props.define?.arg) {
-            const { arg } = scriptSetupRanges.props.define;
-            codegens.push(function* () {
-                yield (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation);
-            });
+    if (scriptSetupRanges.emits.define) {
+        const { typeArg, hasUnionTypeArg } = scriptSetupRanges.emits.define;
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}>`,
+            typeOptionType: typeArg && !hasUnionTypeArg
+                ? scriptSetup.content.slice(typeArg.start, typeArg.end)
+                : undefined,
+        });
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionType)) {
+        if (codes.length === 1) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            yield `,${common_1.newLine}`;
         }
-        if (codegens.length === 1) {
-            yield `props: `;
-            for (const generate of codegens) {
-                yield* generate();
+        else if (codes.length >= 2) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            for (let i = 1; i < codes.length; i++) {
+                yield ` & `;
+                yield codes[i].typeOptionType;
             }
             yield `,${common_1.newLine}`;
         }
-        else if (codegens.length >= 2) {
-            yield `props: {${common_1.newLine}`;
-            for (const generate of codegens) {
+    }
+    else if (codes.every(code => code.optionExp)) {
+        if (codes.length === 1) {
+            yield `emits: `;
+            yield codes[0].optionExp;
+            yield `,${common_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `emits: {${common_1.newLine}`;
+            for (const code of codes) {
                 yield `...`;
-                yield* generate();
+                yield code.optionExp;
                 yield `,${common_1.newLine}`;
             }
             yield `},${common_1.newLine}`;
         }
     }
 }
-function* generateEmitsOption(options, scriptSetup, scriptSetupRanges) {
-    if (!scriptSetupRanges.emits.define && !scriptSetupRanges.defineProp.some(p => p.isModel)) {
-        return;
-    }
-    if (options.vueCompilerOptions.target < 3.5 || scriptSetupRanges.emits.define?.arg || scriptSetupRanges.emits.define?.hasUnionTypeArg) {
-        yield `emits: ({} as __VLS_NormalizeEmits<__VLS_ModelEmitsType`;
-        if (scriptSetupRanges?.emits.define) {
-            yield ` & typeof `;
-            yield scriptSetupRanges.emits.name ?? '__VLS_emit';
+function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
+    const optionExpCodes = [];
+    const typeOptionExpCodes = [];
+    if (ctx.generatedPropsType) {
+        optionExpCodes.push([
+            `{} as `,
+            scriptSetupRanges.props.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
+            `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
+            scriptSetupRanges.props.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
+        ].join(''));
+        typeOptionExpCodes.push(`{} as __VLS_PublicProps`);
+    }
+    if (scriptSetupRanges.props.define?.arg) {
+        const { arg } = scriptSetupRanges.props.define;
+        optionExpCodes.push((0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation));
+    }
+    if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
+        let attrsType = `typeof __VLS_templateResult['attrs']`;
+        if (hasEmitsOption) {
+            attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
         }
-        yield `>),${common_1.newLine}`;
+        const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;
+        const optionType = `${ctx.localTypes.TypePropsToOption}<${propsType}>`;
+        if (optionExpCodes.length) {
+            optionExpCodes.unshift(`{} as ${optionType}`);
+        }
+        else {
+            // workaround for https://github.com/vuejs/core/pull/7419
+            optionExpCodes.unshift(`{} as keyof ${propsType} extends never ? never: ${optionType}`);
+        }
+        typeOptionExpCodes.unshift(`{} as ${attrsType}`);
     }
-    else {
-        yield `__typeEmits: {} as __VLS_ModelEmitsType`;
-        const typeArg = scriptSetupRanges.emits.define?.typeArg;
-        if (typeArg) {
-            yield ` & `;
-            yield scriptSetup.content.slice(typeArg.start, typeArg.end);
+    const useTypeOption = options.vueCompilerOptions.target >= 3.5 && typeOptionExpCodes.length;
+    const useOption = (!useTypeOption || scriptSetupRanges.props.withDefaults) && optionExpCodes.length;
+    if (useTypeOption) {
+        if (typeOptionExpCodes.length === 1) {
+            yield `__typeProps: `;
+            yield typeOptionExpCodes[0];
+            yield `,${common_1.newLine}`;
+        }
+        else if (typeOptionExpCodes.length >= 2) {
+            yield `__typeProps: {${common_1.newLine}`;
+            for (const code of typeOptionExpCodes) {
+                yield `...`;
+                yield code;
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
+        }
+    }
+    if (useOption) {
+        if (optionExpCodes.length === 1) {
+            yield `props: `;
+            yield optionExpCodes[0];
+            yield `,${common_1.newLine}`;
+        }
+        else if (optionExpCodes.length >= 2) {
+            yield `props: {${common_1.newLine}`;
+            for (const code of optionExpCodes) {
+                yield `...`;
+                yield code;
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
         }
-        yield `,${common_1.newLine}`;
     }
 }
 //# sourceMappingURL=component.js.map

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

@@ -1,5 +1,6 @@
+import { InlayHintInfo } from '../types';
 import type { ScriptCodegenOptions } from './index';
-interface HelperType {
+export interface HelperType {
     name: string;
     used?: boolean;
     generated?: boolean;
@@ -12,14 +13,17 @@ export declare function createScriptCodegenContext(options: ScriptCodegenOptions
     scriptSetupGeneratedOffset: number | undefined;
     bypassDefineComponent: boolean;
     bindingNames: Set<string>;
-    helperTypes: {
-        OmitKeepDiscriminatedUnion: HelperType;
-        WithDefaults: HelperType;
-        Prettify: HelperType;
-        WithTemplateSlots: HelperType;
-        PropsChildren: HelperType;
-        TypePropsToOption: HelperType;
+    localTypes: {
+        generate: (names: string[]) => Generator<string, void, unknown>;
+        getUsedNames(): Set<string>;
+        readonly PrettifyLocal: string;
+        readonly OmitKeepDiscriminatedUnion: string;
+        readonly WithDefaults: string;
+        readonly WithTemplateSlots: string;
+        readonly PropsChildren: string;
+        readonly TypePropsToOption: string;
+        readonly OmitIndexSignature: string;
+        readonly PickRefsExpose: string;
     };
-    generateHelperTypes: () => Generator<string, void, unknown>;
+    inlayHints: InlayHintInfo[];
 };
-export {};