@vue/language-core 1.8.12 → 1.8.14

package/out/generators/script.js

@@ -28,7 +28,6 @@ const language_core_1 = require("@volar/language-core");
 const source_map_1 = require("@volar/source-map");
 const muggle = __importStar(require("muggle-string"));
 const path_1 = require("path");
-const sharedTypes = __importStar(require("../utils/globalTypes"));
 const shared_1 = require("../utils/shared");
 const transform_1 = require("../utils/transform");
 function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htmlGen, compilerOptions, vueCompilerOptions, codegenStack) {
@@ -55,31 +54,34 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
         scriptSetupRanges = {
             bindings: [],
             emitsAssignName: undefined,
-            emitsRuntimeArg: undefined,
-            emitsTypeArg: undefined,
-            emitsTypeNums: 0,
             exposeRuntimeArg: undefined,
             leadingCommentEndOffset: 0,
             importSectionEndOffset: 0,
             defineProps: undefined,
+            defineSlots: undefined,
+            defineEmits: undefined,
+            defineExpose: undefined,
+            slotsAssignName: undefined,
             propsAssignName: undefined,
             propsRuntimeArg: undefined,
             propsTypeArg: undefined,
-            slotsTypeArg: undefined,
             withDefaultsArg: undefined,
             defineProp: [],
         };
     }
     //#endregion
+    const bindingNames = new Set([
+        ...scriptRanges?.bindings.map(range => sfc.script.content.substring(range.start, range.end)) ?? [],
+        ...scriptSetupRanges?.bindings.map(range => sfc.scriptSetup.content.substring(range.start, range.end)) ?? [],
+    ]);
     const bypassDefineComponent = lang === 'js' || lang === 'jsx';
     const usedHelperTypes = {
         DefinePropsToOptions: false,
-        mergePropDefaults: false,
-        EmitsTypeHelpers: false,
+        MergePropDefaults: false,
         WithTemplateSlots: false,
         PropsChildren: false,
     };
-    codes.push(`/* ${Object.entries(vueCompilerOptions).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(', ')} */\n`);
+    codes.push(`/* __placeholder__ */\n`);
     let generatedTemplate = false;
     generateSrc();
     generateScriptSetupImports();
@@ -88,7 +90,7 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
     generateHelperTypes();
     generateScriptContentAfterExportDefault();
     if (!generatedTemplate) {
-        generateTemplate();
+        generateTemplate(false);
     }
     if (sfc.scriptSetup) {
         // for code action edits
@@ -105,7 +107,6 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
         mirrorBehaviorMappings,
     };
     function generateHelperTypes() {
-        let usedPrettify = false;
         if (usedHelperTypes.DefinePropsToOptions) {
             if (compilerOptions.exactOptionalPropertyTypes) {
                 codes.push(`type __VLS_TypePropsToRuntimeProps<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 } };\n`);
@@ -115,29 +116,13 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
                 codes.push(`type __VLS_TypePropsToRuntimeProps<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 } };\n`);
             }
         }
-        if (usedHelperTypes.mergePropDefaults) {
+        if (usedHelperTypes.MergePropDefaults) {
             codes.push(`type __VLS_WithDefaults<P, D> = {
 					// use 'keyof Pick<P, keyof P>' instead of 'keyof P' to keep props jsdoc
 					[K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
 						default: D[K]
 					}> : P[K]
 				};\n`);
-            usedPrettify = true;
-        }
-        if (usedHelperTypes.EmitsTypeHelpers) {
-            // fix https://github.com/vuejs/language-tools/issues/926
-            codes.push('type __VLS_UnionToIntersection<U> = __VLS_Prettify<(U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never>;\n');
-            usedPrettify = true;
-            if (scriptSetupRanges && scriptSetupRanges.emitsTypeNums !== -1) {
-                codes.push(sharedTypes.genConstructorOverloads('__VLS_ConstructorOverloads', scriptSetupRanges.emitsTypeNums));
-            }
-            else {
-                codes.push(sharedTypes.genConstructorOverloads('__VLS_ConstructorOverloads'));
-            }
-            codes.push(`type __VLS_NormalizeEmits<T> = __VLS_ConstructorOverloads<T> & {
-				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
-			}\n`);
-            ;
         }
         if (usedHelperTypes.WithTemplateSlots) {
             codes.push(`type __VLS_WithTemplateSlots<T, S> = T & { new(): {\n`, `$slots: S;\n`);
@@ -150,9 +135,6 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
         if (usedHelperTypes.PropsChildren) {
             codes.push(`type __VLS_PropsChildren<S> = { [K in keyof (boolean extends (JSX.ElementChildrenAttribute extends never ? true : false) ? never : JSX.ElementChildrenAttribute)]?: S; };\n`);
         }
-        if (usedPrettify) {
-            codes.push(`type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};\n`);
-        }
     }
     function generateSrc() {
         if (!sfc.script?.src)
@@ -293,22 +275,23 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
             }
             codes.push(`>`);
             codes.push('(\n');
-            codes.push(`__VLS_props: Awaited<typeof __VLS_setup>['props']`, `& import('${vueCompilerOptions.lib}').VNodeProps`, `& import('${vueCompilerOptions.lib}').AllowedComponentProps`, `& import('${vueCompilerOptions.lib}').ComponentCustomProps,\n`);
-            codes.push(`__VLS_ctx?: Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>,\n`);
+            codes.push(`__VLS_props: Awaited<typeof __VLS_setup>['props'],\n`);
+            codes.push(`__VLS_ctx?: __VLS_Prettify<Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>>,\n`); // use __VLS_Prettify for less dts code
             codes.push(`__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],\n`);
             codes.push('__VLS_setup = (async () => {\n');
             scriptSetupGeneratedOffset = generateSetupFunction(true, 'none', definePropMirrors);
-            //#region exposed
-            codes.push(`const __VLS_exposed = `);
-            if (scriptSetupRanges.exposeRuntimeArg) {
-                addVirtualCode('scriptSetup', scriptSetupRanges.exposeRuntimeArg.start, scriptSetupRanges.exposeRuntimeArg.end);
+            //#region props
+            codes.push(`const __VLS_fnComponent = `);
+            codes.push(`(await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+            if (scriptSetupRanges.propsRuntimeArg) {
+                codes.push(`props: `);
+                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsRuntimeArg.start, scriptSetupRanges.propsRuntimeArg.end);
+                codes.push(`,\n`);
             }
-            else {
-                codes.push(`{}`);
+            if (scriptSetupRanges.defineEmits) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emitsAssignName ?? '__VLS_emit', `>),\n`);
             }
-            codes.push(';\n');
-            //#endregion
-            //#region props
+            codes.push(`});\n`);
             if (scriptSetupRanges.defineProp.length) {
                 codes.push(`const __VLS_defaults = {\n`);
                 for (const defineProp of scriptSetupRanges.defineProp) {
@@ -326,10 +309,7 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
                 }
                 codes.push(`};\n`);
             }
-            codes.push(`let __VLS_props!: {}`);
-            if (scriptSetupRanges.propsRuntimeArg) {
-                codes.push(` & InstanceType<typeof __VLS_publicComponent>['$props']`);
-            }
+            codes.push(`let __VLS_fnPropsTypeOnly!: {}`); // TODO: reuse __VLS_fnPropsTypeOnly even without generic, and remove __VLS_propsOption_defineProp
             if (scriptSetupRanges.propsTypeArg) {
                 codes.push(` & `);
                 addVirtualCode('scriptSetup', scriptSetupRanges.propsTypeArg.start, scriptSetupRanges.propsTypeArg.end);
@@ -359,33 +339,23 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
                 }
                 codes.push(`}`);
             }
-            if (scriptSetupRanges.slotsTypeArg && vueCompilerOptions.jsxSlots) {
-                usedHelperTypes.PropsChildren = true;
-                codes.push(` & __VLS_PropsChildren<`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.slotsTypeArg.start, scriptSetupRanges.slotsTypeArg.end);
-                codes.push('>');
-            }
             codes.push(`;\n`);
-            //#endregion
-            //#region emits
-            codes.push(`const __VLS_emit = `);
-            if (scriptSetupRanges.emitsTypeArg) {
-                codes.push('{} as ');
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsTypeArg.start, scriptSetupRanges.emitsTypeArg.end);
-                codes.push(';\n');
-            }
-            else if (scriptSetupRanges.emitsRuntimeArg) {
-                codes.push(`defineEmits(`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsRuntimeArg.start, scriptSetupRanges.emitsRuntimeArg.end);
-                codes.push(');\n');
+            codes.push(`let __VLS_fnPropsDefineComponent!: InstanceType<typeof __VLS_fnComponent>['$props']`);
+            codes.push(`;\n`);
+            codes.push(`let __VLS_fnPropsSlots!: `);
+            if (scriptSetupRanges.defineSlots && vueCompilerOptions.jsxSlots) {
+                usedHelperTypes.PropsChildren = true;
+                codes.push(`__VLS_PropsChildren<typeof __VLS_slots>`);
             }
             else {
-                codes.push('{} as any;\n');
+                codes.push(`{}`);
             }
+            codes.push(`;\n`);
+            codes.push(`let __VLS_defaultProps!: `, `import('${vueCompilerOptions.lib}').VNodeProps`, `& import('${vueCompilerOptions.lib}').AllowedComponentProps`, `& import('${vueCompilerOptions.lib}').ComponentCustomProps`, `;\n`);
             //#endregion
             codes.push('return {} as {\n');
-            codes.push(`props: typeof __VLS_props,\n`);
-            codes.push('expose(exposed: typeof __VLS_exposed): void,\n');
+            codes.push(`props: __VLS_Prettify<Omit<typeof __VLS_fnPropsDefineComponent & typeof __VLS_fnPropsTypeOnly, keyof typeof __VLS_defaultProps>> & typeof __VLS_fnPropsSlots & typeof __VLS_defaultProps,\n`);
+            codes.push(`expose(exposed: ${scriptSetupRanges.exposeRuntimeArg ? 'typeof __VLS_exposed' : '{}'}): void,\n`);
             codes.push('attrs: any,\n');
             codes.push('slots: ReturnType<typeof __VLS_template>,\n');
             codes.push('emit: typeof __VLS_emit');
@@ -433,17 +403,10 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
         const definePropProposalA = sfc.scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
         const definePropProposalB = sfc.scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition') || vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
         if (vueCompilerOptions.target >= 3.3) {
-            const bindings = new Set(scriptSetupRanges.bindings.map(range => sfc.scriptSetup.content.substring(range.start, range.end)));
             codes.push('const { ');
-            for (const [macro, aliases] of Object.entries(vueCompilerOptions.macros)) {
-                for (const alias of aliases) {
-                    if (!bindings.has(alias)) {
-                        codes.push(macro);
-                        if (alias !== macro) {
-                            codes.push(` : ${alias}`);
-                        }
-                        codes.push(`, `);
-                    }
+            for (const macro of Object.keys(vueCompilerOptions.macros)) {
+                if (!bindingNames.has(macro)) {
+                    codes.push(macro, ', ');
                 }
             }
             codes.push(`} = await import('${vueCompilerOptions.lib}');\n`);
@@ -463,7 +426,41 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
 `.trim() + '\n');
         }
         const scriptSetupGeneratedOffset = muggle.getLength(codes) - scriptSetupRanges.importSectionEndOffset;
-        addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset);
+        let setupCodeModifies = [];
+        if (scriptSetupRanges.defineSlots && !scriptSetupRanges.slotsAssignName) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_slots = `), scriptSetupRanges.defineSlots.start, scriptSetupRanges.defineSlots.start]);
+        }
+        if (scriptSetupRanges.defineEmits && !scriptSetupRanges.emitsAssignName) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_emit = `), scriptSetupRanges.defineEmits.start, scriptSetupRanges.defineEmits.start]);
+        }
+        if (scriptSetupRanges.defineExpose && scriptSetupRanges.exposeRuntimeArg) {
+            setupCodeModifies.push([() => {
+                    codes.push(`const __VLS_exposed = `);
+                    addVirtualCode('scriptSetup', scriptSetupRanges.exposeRuntimeArg.start, scriptSetupRanges.exposeRuntimeArg.end);
+                    codes.push(`;`);
+                    addVirtualCode('scriptSetup', scriptSetupRanges.defineExpose.start, scriptSetupRanges.exposeRuntimeArg.start);
+                    codes.push(`__VLS_exposed`);
+                    addVirtualCode('scriptSetup', scriptSetupRanges.exposeRuntimeArg.end, scriptSetupRanges.defineExpose.end);
+                }, scriptSetupRanges.defineExpose.start, scriptSetupRanges.defineExpose.end]);
+        }
+        setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
+        if (setupCodeModifies.length) {
+            addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset, setupCodeModifies[0][1]);
+            while (setupCodeModifies.length) {
+                const [generate, _, end] = setupCodeModifies.shift();
+                generate();
+                if (setupCodeModifies.length) {
+                    const nextStart = setupCodeModifies[0][1];
+                    addVirtualCode('scriptSetup', end, nextStart);
+                }
+                else {
+                    addVirtualCode('scriptSetup', end);
+                }
+            }
+        }
+        else {
+            addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset);
+        }
         if (scriptSetupRanges.propsTypeArg && scriptSetupRanges.withDefaultsArg) {
             // fix https://github.com/vuejs/language-tools/issues/1187
             codes.push(`const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`);
@@ -504,16 +501,54 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
             }
             codes.push(`};\n`);
         }
+        generateTemplate(functional);
+        if (mode === 'return' || mode === 'export') {
+            if (!vueCompilerOptions.skipTemplateCodegen && (htmlGen?.hasSlot || scriptSetupRanges?.defineSlots)) {
+                usedHelperTypes.WithTemplateSlots = true;
+                codes.push(`const __VLS_component = `);
+                generateComponent(functional);
+                codes.push(`;\n`);
+                codes.push(mode === 'return' ? 'return ' : 'export default ');
+                codes.push(`{} as __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;\n`);
+            }
+            else {
+                codes.push(mode === 'return' ? 'return ' : 'export default ');
+                generateComponent(functional);
+                codes.push(`;\n`);
+            }
+        }
+        if (mode === 'export') {
+            generateExportDefaultEndMapping();
+        }
+        return scriptSetupGeneratedOffset;
+    }
+    function generateComponent(functional) {
+        if (!scriptSetupRanges)
+            return;
         if (scriptRanges?.exportDefault && scriptRanges.exportDefault.expression.start !== scriptRanges.exportDefault.args.start) {
             // use defineComponent() from user space code if it exist
-            codes.push(`const __VLS_publicComponent = `);
             addVirtualCode('script', scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.args.start);
             codes.push(`{\n`);
         }
         else {
-            codes.push(`const __VLS_publicComponent = (await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+            codes.push(`(await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+        }
+        generateComponentOptions(functional);
+        codes.push(`setup() {\n`);
+        codes.push(`return {\n`);
+        generateSetupReturns();
+        if (scriptSetupRanges.exposeRuntimeArg) {
+            codes.push(`...__VLS_exposed,\n`);
+        }
+        codes.push(`};\n`);
+        codes.push(`},\n`);
+        if (scriptRanges?.exportDefault?.args) {
+            addVirtualCode('script', scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1);
         }
-        if (!bypassDefineComponent) {
+        codes.push(`})`);
+    }
+    function generateComponentOptions(functional) {
+        if (scriptSetupRanges && !bypassDefineComponent) {
             if (scriptSetupRanges.propsRuntimeArg || scriptSetupRanges.propsTypeArg || (!functional && scriptSetupRanges.defineProp.length)) {
                 codes.push(`props: {\n`);
                 if (scriptSetupRanges.propsRuntimeArg) {
@@ -525,12 +560,12 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                     usedHelperTypes.DefinePropsToOptions = true;
                     codes.push('...{} as ');
                     if (scriptSetupRanges.withDefaultsArg) {
-                        usedHelperTypes.mergePropDefaults = true;
+                        usedHelperTypes.MergePropDefaults = true;
                         codes.push(`__VLS_WithDefaults<`);
                     }
                     codes.push(`__VLS_TypePropsToRuntimeProps<`);
                     if (functional) {
-                        codes.push(`typeof __VLS_props`);
+                        codes.push(`typeof __VLS_fnPropsTypeOnly`);
                     }
                     else {
                         addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsTypeArg.start, scriptSetupRanges.propsTypeArg.end);
@@ -547,21 +582,13 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                 }
                 codes.push(`},\n`);
             }
-            if (scriptSetupRanges.emitsTypeArg) {
-                usedHelperTypes.EmitsTypeHelpers = true;
-                codes.push(`emits: ({} as __VLS_UnionToIntersection<__VLS_NormalizeEmits<`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsTypeArg.start, scriptSetupRanges.emitsTypeArg.end);
-                codes.push(`>>),\n`);
-            }
-            else if (scriptSetupRanges.emitsRuntimeArg) {
-                codes.push(`emits: (`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsRuntimeArg.start, scriptSetupRanges.emitsRuntimeArg.end);
-                codes.push(`),\n`);
+            if (scriptSetupRanges.defineEmits) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emitsAssignName ?? '__VLS_emit', `>),\n`);
             }
         }
-        codes.push(`setup() {\n`);
-        codes.push(`return {\n`);
-        if (bypassDefineComponent) {
+    }
+    function generateSetupReturns() {
+        if (scriptSetupRanges && bypassDefineComponent) {
             // fill $props
             if (scriptSetupRanges.propsTypeArg) {
                 // NOTE: defineProps is inaccurate for $props
@@ -576,67 +603,20 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                 codes.push(`)),\n`);
             }
             // fill $emit
-            if (scriptSetupRanges.emitsAssignName) {
-                codes.push(`$emit: ${scriptSetupRanges.emitsAssignName},\n`);
-            }
-            else if (scriptSetupRanges.emitsTypeArg) {
-                codes.push(`$emit: defineEmits<`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsTypeArg.start, scriptSetupRanges.emitsTypeArg.end);
-                codes.push(`>(),\n`);
-            }
-            else if (scriptSetupRanges.emitsRuntimeArg) {
-                codes.push(`$emit: defineEmits(`);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.emitsRuntimeArg.start, scriptSetupRanges.emitsRuntimeArg.end);
-                codes.push(`),\n`);
-            }
-        }
-        if (scriptSetupRanges.exposeRuntimeArg) {
-            codes.push(`...(`);
-            addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.exposeRuntimeArg.start, scriptSetupRanges.exposeRuntimeArg.end);
-            codes.push(`),\n`);
-        }
-        codes.push(`};\n`);
-        codes.push(`},\n`);
-        if (scriptRanges?.exportDefault?.args) {
-            addVirtualCode('script', scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1);
-        }
-        codes.push(`});\n`);
-        generateTemplate();
-        if (mode === 'return') {
-            codes.push(`return `);
-        }
-        else if (mode === 'export') {
-            codes.push('export default ');
-        }
-        if (mode === 'return' || mode === 'export') {
-            if (!vueCompilerOptions.skipTemplateCodegen && (htmlGen?.hasSlot || scriptSetupRanges?.slotsTypeArg)) {
-                usedHelperTypes.WithTemplateSlots = true;
-                codes.push(`{} as __VLS_WithTemplateSlots<typeof __VLS_publicComponent, ReturnType<typeof __VLS_template>>;`);
-            }
-            else {
-                codes.push(`{} as typeof __VLS_publicComponent;`);
+            if (scriptSetupRanges.defineEmits) {
+                codes.push(`$emit: ${scriptSetupRanges.emitsAssignName ?? '__VLS_emit'},\n`);
             }
         }
-        if (mode === 'export') {
-            generateExportDefaultEndMapping();
-        }
-        return scriptSetupGeneratedOffset;
     }
-    function generateTemplate() {
+    function generateTemplate(functional) {
         generatedTemplate = true;
         if (!vueCompilerOptions.skipTemplateCodegen) {
             generateExportOptions();
             generateConstNameOption();
-            if (scriptSetupRanges?.slotsTypeArg && sfc.scriptSetup) {
-                codes.push(`var __VLS_slots!: `);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.slotsTypeArg.start, scriptSetupRanges.slotsTypeArg.end);
-                codes.push(';\n');
-            }
-            ;
             codes.push(`function __VLS_template() {\n`);
             const templateGened = generateTemplateContext();
             codes.push(`}\n`);
-            generateComponentForTemplateUsage(templateGened.cssIds);
+            generateComponentForTemplateUsage(functional, templateGened.cssIds);
         }
         else {
             codes.push(`function __VLS_template() {\n`);
@@ -647,29 +627,13 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
             codes.push(`}\n`);
         }
     }
-    function generateComponentForTemplateUsage(cssIds) {
+    function generateComponentForTemplateUsage(functional, cssIds) {
         if (sfc.scriptSetup && scriptSetupRanges) {
             codes.push(`const __VLS_internalComponent = (await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+            generateComponentOptions(functional);
             codes.push(`setup() {\n`);
             codes.push(`return {\n`);
-            // fill ctx from props
-            if (bypassDefineComponent) {
-                if (scriptSetupRanges.propsAssignName) {
-                    codes.push(`...${scriptSetupRanges.propsAssignName},\n`);
-                }
-                else if (scriptSetupRanges.withDefaultsArg && scriptSetupRanges.propsTypeArg) {
-                    codes.push(`...withDefaults(defineProps<`);
-                    addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsTypeArg.start, scriptSetupRanges.propsTypeArg.end);
-                    codes.push(`>(), `);
-                    addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.withDefaultsArg.start, scriptSetupRanges.withDefaultsArg.end);
-                    codes.push(`),\n`);
-                }
-                else if (scriptSetupRanges.propsRuntimeArg) {
-                    codes.push(`...defineProps(`);
-                    addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsRuntimeArg.start, scriptSetupRanges.propsRuntimeArg.end);
-                    codes.push(`),\n`);
-                }
-            }
+            generateSetupReturns();
             // bindings
             const templateUsageVars = getTemplateUsageVars();
             for (const [content, bindings] of [
@@ -750,9 +714,6 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
     function generateTemplateContext() {
         const useGlobalThisTypeInCtx = fileName.endsWith('.html');
         codes.push(`let __VLS_ctx!: ${useGlobalThisTypeInCtx ? 'typeof globalThis &' : ''}`);
-        if (sfc.scriptSetup) {
-            codes.push(`InstanceType<__VLS_PickNotAny<typeof __VLS_publicComponent, new () => {}>> & `);
-        }
         codes.push(`InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>> & {\n`);
         /* CSS Module */
         for (let i = 0; i < _sfc.styles.length; i++) {
@@ -769,7 +730,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         /* Components */
         codes.push('/* Components */\n');
         codes.push(`let __VLS_otherComponents!: NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}> & typeof __VLS_componentsOption;\n`);
-        codes.push(`let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & typeof __VLS_publicComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: typeof __VLS_slots })>;\n`);
+        codes.push(`let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: typeof ${scriptSetupRanges?.slotsAssignName ?? '__VLS_slots'} })>;\n`);
         codes.push(`let __VLS_localComponents!: typeof __VLS_otherComponents & Omit<typeof __VLS_own, keyof typeof __VLS_otherComponents>;\n`);
         codes.push(`let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents & typeof __VLS_ctx;\n`); // for html completion, TS references...
         /* Style Scoped */
@@ -800,16 +761,11 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         }
         if (!htmlGen) {
             codes.push(`// no template\n`);
-            if (scriptSetupRanges?.slotsTypeArg && sfc.scriptSetup) {
-                codes.push(`let __VLS_slots!: `);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.slotsTypeArg.start, scriptSetupRanges.slotsTypeArg.end);
-                codes.push(`;\n`);
-            }
-            else {
+            if (!scriptSetupRanges?.defineSlots) {
                 codes.push(`const __VLS_slots = {};\n`);
             }
         }
-        codes.push(`return __VLS_slots;\n`);
+        codes.push(`return ${scriptSetupRanges?.slotsAssignName ?? '__VLS_slots'};\n`);
         return { cssIds };
         function generateCssClassProperty(styleIndex, className, classRange, propertyType, optional, referencesCodeLens) {
             codes.push(`\n & { `);
@@ -874,13 +830,6 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
     function getTemplateUsageVars() {
         const usageVars = new Set();
         if (htmlGen) {
-            let bindingNames = [];
-            if (scriptSetupRanges) {
-                bindingNames = bindingNames.concat(scriptSetupRanges.bindings.map(range => sfc.scriptSetup?.content.substring(range.start, range.end) ?? ''));
-            }
-            if (scriptRanges) {
-                bindingNames = bindingNames.concat(scriptRanges.bindings.map(range => sfc.script?.content.substring(range.start, range.end) ?? ''));
-            }
             // fix import components unused report
             for (const varName of bindingNames) {
                 if (!!htmlGen.tagNames[varName] || !!htmlGen.tagNames[(0, shared_1.hyphenateTag)(varName)]) {

package/out/generators/template.d.ts

@@ -5,7 +5,7 @@ import * as muggle from 'muggle-string';
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import { Sfc, VueCompilerOptions } from '../types';
 type Code = Segment<FileRangeCapabilities>;
-export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sourceTemplate: string, sourceLang: string, sfc: Sfc, hasScriptSetupSlots: boolean, codegenStack: boolean): {
+export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sourceTemplate: string, sourceLang: string, sfc: Sfc, hasScriptSetupSlots: boolean, slotsAssignName: string | undefined, codegenStack: boolean): {
     codes: Code[];
     codeStacks: muggle.StackNode[];
     formatCodes: Code[];

package/out/generators/template.js

@@ -84,7 +84,7 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourceLang, sfc, hasScriptSetupSlots, codegenStack) {
+function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourceLang, sfc, hasScriptSetupSlots, slotsAssignName, codegenStack) {
     const nativeTags = new Set(vueCompilerOptions.nativeTags);
     const [codes, codeStacks] = codegenStack ? muggle.track([]) : [[], []];
     const [formatCodes, formatCodeStacks] = codegenStack ? muggle.track([]) : [[], []];
@@ -98,6 +98,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     const scopedClasses = [];
     const blockConditions = [];
     const hasSlotElements = new Set();
+    const componentCtxVar2EmitEventsVar = new Map();
     let hasSlot = false;
     let elementIndex = 0;
     let ignoreStart;
@@ -596,7 +597,10 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
         }
         if (tag !== 'template' && tag !== 'slot') {
             componentCtxVar = `__VLS_${elementIndex++}`;
+            const componentEventsVar = `__VLS_${elementIndex++}`;
             codes.push(`const ${componentCtxVar} = __VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance})!;\n`);
+            codes.push(`let ${componentEventsVar}!: __VLS_NormalizeEmits<typeof ${componentCtxVar}.emit>;\n`);
+            componentCtxVar2EmitEventsVar.set(componentCtxVar, componentEventsVar);
             parentEl = node;
         }
         //#region
@@ -744,8 +748,9 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
             if (prop.type === 7 /* CompilerDOM.NodeTypes.DIRECTIVE */
                 && prop.name === 'on'
                 && prop.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                const eventsVar = componentCtxVar2EmitEventsVar.get(componentCtxVar);
                 const eventVar = `__VLS_${elementIndex++}`;
-                codes.push(`let ${eventVar} = { '${prop.arg.loc.source}': `, `__VLS_pickEvent(${componentCtxVar}.emit!, '${prop.arg.loc.source}' as const, {} as __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>`, ...createPropertyAccessCode([
+                codes.push(`let ${eventVar} = { '${prop.arg.loc.source}': `, `__VLS_pickEvent(${eventsVar}['${prop.arg.loc.source}'], ({} as __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>)`, ...createPropertyAccessCode([
                     (0, shared_1.camelize)('on-' + prop.arg.loc.source),
                     'template',
                     [prop.arg.loc.start.offset, prop.arg.loc.end.offset],
@@ -1170,7 +1175,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
         const varSlot = `__VLS_${elementIndex++}`;
         const slotNameExpNode = getSlotNameExpNode();
         if (hasScriptSetupSlots) {
-            codes.push('__VLS_normalizeSlot(', ['', 'template', node.loc.start.offset, capabilitiesPresets.diagnosticOnly], '__VLS_slots[', ['', 'template', node.loc.start.offset, capabilitiesPresets.diagnosticOnly], slotNameExpNode?.content ?? `('${getSlotName()}' as const)`, ['', 'template', node.loc.end.offset, capabilitiesPresets.diagnosticOnly], ']', ['', 'template', node.loc.end.offset, capabilitiesPresets.diagnosticOnly], ')?.(', ['', 'template', startTagOffset, capabilitiesPresets.diagnosticOnly], '{\n');
+            codes.push('__VLS_normalizeSlot(', ['', 'template', node.loc.start.offset, capabilitiesPresets.diagnosticOnly], `${slotsAssignName ?? '__VLS_slots'}[`, ['', 'template', node.loc.start.offset, capabilitiesPresets.diagnosticOnly], slotNameExpNode?.content ?? `('${getSlotName()}' as const)`, ['', 'template', node.loc.end.offset, capabilitiesPresets.diagnosticOnly], ']', ['', 'template', node.loc.end.offset, capabilitiesPresets.diagnosticOnly], ')?.(', ['', 'template', startTagOffset, capabilitiesPresets.diagnosticOnly], '{\n');
         }
         else {
             codes.push(`var ${varSlot} = {\n`);

package/out/parsers/scriptSetupRanges.d.ts

@@ -8,14 +8,14 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib
     bindings: TextRange[];
     withDefaultsArg: TextRange | undefined;
     defineProps: TextRange | undefined;
+    defineSlots: TextRange | undefined;
+    defineEmits: TextRange | undefined;
+    defineExpose: TextRange | undefined;
     propsAssignName: string | undefined;
     propsRuntimeArg: TextRange | undefined;
     propsTypeArg: TextRange | undefined;
-    slotsTypeArg: TextRange | undefined;
+    slotsAssignName: string | undefined;
     emitsAssignName: string | undefined;
-    emitsRuntimeArg: TextRange | undefined;
-    emitsTypeArg: TextRange | undefined;
-    emitsTypeNums: number;
     exposeRuntimeArg: TextRange | undefined;
     defineProp: {
         name: TextRange | undefined;

package/out/parsers/scriptSetupRanges.js

@@ -9,12 +9,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     let defineProps;
     let propsRuntimeArg;
     let propsTypeArg;
-    let slotsTypeArg;
+    let defineSlots;
+    let defineEmits;
+    let defineExpose;
+    let slotsAssignName;
     let emitsAssignName;
-    let emitsRuntimeArg;
-    let emitsTypeArg;
     let exposeRuntimeArg;
-    let emitsTypeNums = -1;
     const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
     const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
@@ -47,14 +47,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         bindings,
         withDefaultsArg,
         defineProps,
+        defineSlots,
+        defineEmits,
+        defineExpose,
         propsAssignName,
         propsRuntimeArg,
         propsTypeArg,
-        slotsTypeArg,
+        slotsAssignName,
         emitsAssignName,
-        emitsRuntimeArg,
-        emitsTypeArg,
-        emitsTypeNums,
         exposeRuntimeArg,
         defineProp,
     };
@@ -140,51 +140,34 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     });
                 }
             }
-            if (vueCompilerOptions.macros.defineProps.includes(callText)
-                || vueCompilerOptions.macros.defineSlots.includes(callText)
-                || vueCompilerOptions.macros.defineEmits.includes(callText)
-                || vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                if (vueCompilerOptions.macros.defineProps.includes(callText)) {
-                    defineProps = _getStartEnd(node);
+            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                defineSlots = _getStartEnd(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    slotsAssignName = parent.name.getText(ast);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                defineEmits = _getStartEnd(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    emitsAssignName = parent.name.getText(ast);
                 }
+            }
+            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                defineExpose = _getStartEnd(node);
                 if (node.arguments.length) {
-                    const runtimeArg = node.arguments[0];
-                    if (vueCompilerOptions.macros.defineProps.includes(callText)) {
-                        propsRuntimeArg = _getStartEnd(runtimeArg);
-                        if (ts.isVariableDeclaration(parent)) {
-                            propsAssignName = parent.name.getText(ast);
-                        }
-                    }
-                    else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                        emitsRuntimeArg = _getStartEnd(runtimeArg);
-                        if (ts.isVariableDeclaration(parent)) {
-                            emitsAssignName = parent.name.getText(ast);
-                        }
-                    }
-                    else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                        exposeRuntimeArg = _getStartEnd(runtimeArg);
-                    }
+                    exposeRuntimeArg = _getStartEnd(node.arguments[0]);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                defineProps = _getStartEnd(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    propsAssignName = parent.name.getText(ast);
+                }
+                if (node.arguments.length) {
+                    propsRuntimeArg = _getStartEnd(node.arguments[0]);
                 }
                 if (node.typeArguments?.length) {
-                    const typeArg = node.typeArguments[0];
-                    if (vueCompilerOptions.macros.defineProps.includes(callText)) {
-                        propsTypeArg = _getStartEnd(typeArg);
-                        if (ts.isVariableDeclaration(parent)) {
-                            propsAssignName = parent.name.getText(ast);
-                        }
-                    }
-                    if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
-                        slotsTypeArg = _getStartEnd(typeArg);
-                    }
-                    else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                        emitsTypeArg = _getStartEnd(typeArg);
-                        if (ts.isTypeLiteralNode(typeArg)) {
-                            emitsTypeNums = typeArg.members.length;
-                        }
-                        if (ts.isVariableDeclaration(parent)) {
-                            emitsAssignName = parent.name.getText(ast);
-                        }
-                    }
+                    propsTypeArg = _getStartEnd(node.typeArguments[0]);
                 }
             }
             else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {

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

@@ -18,14 +18,14 @@ export declare const tsCodegen: WeakMap<Sfc, {
         bindings: import("../types").TextRange[];
         withDefaultsArg: import("../types").TextRange | undefined;
         defineProps: import("../types").TextRange | undefined;
+        defineSlots: import("../types").TextRange | undefined;
+        defineEmits: import("../types").TextRange | undefined;
+        defineExpose: import("../types").TextRange | undefined;
         propsAssignName: string | undefined;
         propsRuntimeArg: import("../types").TextRange | undefined;
         propsTypeArg: import("../types").TextRange | undefined;
-        slotsTypeArg: import("../types").TextRange | undefined;
+        slotsAssignName: string | undefined;
         emitsAssignName: string | undefined;
-        emitsRuntimeArg: import("../types").TextRange | undefined;
-        emitsTypeArg: import("../types").TextRange | undefined;
-        emitsTypeNums: number;
         exposeRuntimeArg: import("../types").TextRange | undefined;
         defineProp: {
             name: import("../types").TextRange | undefined;

package/out/plugins/vue-tsx.js

@@ -138,11 +138,15 @@ function createTsx(fileName, _sfc, { vueCompilerOptions, compilerOptions, codege
     const htmlGen = (0, reactivity_1.computed)(() => {
         if (!_sfc.templateAst)
             return;
-        return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, codegenStack);
+        return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, slotsAssignName.value, codegenStack);
     });
-    const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false); // remove when https://github.com/vuejs/core/pull/5912 merged
+    //#region remove when https://github.com/vuejs/core/pull/5912 merged
+    const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false);
+    const slotsAssignName = (0, reactivity_1.shallowRef)();
+    //#endregion
     const tsxGen = (0, reactivity_1.computed)(() => {
-        hasScriptSetupSlots.value = !!scriptSetupRanges.value?.slotsTypeArg;
+        hasScriptSetupSlots.value = !!scriptSetupRanges.value?.defineSlots;
+        slotsAssignName.value = scriptSetupRanges.value?.slotsAssignName;
         return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, htmlGen.value, compilerOptions, vueCompilerOptions, codegenStack);
     });
     return {

package/out/utils/globalTypes.d.ts

@@ -1,5 +1,4 @@
 import { VueCompilerOptions } from '../types';
 export declare const baseName = "__VLS_types.d.ts";
 export declare function getTypesCode(vueCompilerOptions: VueCompilerOptions): string;
-export declare function genConstructorOverloads(name?: string, nums?: number): string;
 //# sourceMappingURL=globalTypes.d.ts.map

package/out/utils/globalTypes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.genConstructorOverloads = exports.getTypesCode = exports.baseName = void 0;
+exports.getTypesCode = exports.baseName = void 0;
 const shared_1 = require("./shared");
 exports.baseName = '__VLS_types.d.ts';
 function getTypesCode(vueCompilerOptions) {
@@ -13,9 +13,7 @@ type __VLS_Element = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.Element, JSX
 type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
 type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
 
-type __VLS_Prettify<T> = {
-	[K in keyof T]: T[K];
-} & {};
+type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};
 
 type __VLS_GlobalComponents =
 	__VLS_PickNotAny<import('vue').GlobalComponents, {}>
@@ -68,26 +66,6 @@ type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string,
 
 type __VLS_FillingEventArg_ParametersLength<E extends (...args: any) => any> = __VLS_IsAny<Parameters<E>> extends true ? -1 : Parameters<E>['length'];
 type __VLS_FillingEventArg<E> = E extends (...args: any) => any ? __VLS_FillingEventArg_ParametersLength<E> extends 0 ? ($event?: undefined) => ReturnType<E> : E : E;
-type __VLS_EmitEvent<F, E> =
-	F extends {
-		(event: E, ...payload: infer P): any
-	} ? (...payload: P) => void
-	: F extends {
-		(event: E, ...payload: infer P): any
-		(...args: any): any
-	} ? (...payload: P) => void
-	: F extends {
-		(event: E, ...payload: infer P): any
-		(...args: any): any
-		(...args: any): any
-	} ? (...payload: P) => void
-	: F extends {
-		(event: E, ...payload: infer P): any
-		(...args: any): any
-		(...args: any): any
-		(...args: any): any
-	} ? (...payload: P) => void
-	: unknown | '[Type Warning] Volar could not infer $emit event more than 4 overloads without DefineComponent. see https://github.com/vuejs/language-tools/issues/60';
 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: (K extends { $props: infer Props } ? Props : any)${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: {
@@ -100,10 +78,10 @@ declare function __VLS_asFunctionalComponent<T, K = T extends new (...args: any)
 	: (_: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'} } };
 declare function __VLS_elementAsFunctionalComponent<T>(t: T): (_: T${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: T${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'} } };
 declare function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
-declare function __VLS_pickEvent<Emit, K, E>(emit: Emit, emitKey: K, event: E): __VLS_FillingEventArg<
+declare function __VLS_pickEvent<E1, E2>(emitEvent: E1, propEvent: E2): __VLS_FillingEventArg<
 	__VLS_PickNotAny<
-		__VLS_AsFunctionOrAny<E>,
-		__VLS_AsFunctionOrAny<__VLS_EmitEvent<Emit, K>>
+		__VLS_AsFunctionOrAny<E2>,
+		__VLS_AsFunctionOrAny<E1>
 	>
 > | undefined;
 declare function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __VLS_PickNotAny<
@@ -117,39 +95,34 @@ type __VLS_FunctionalComponentProps<T, K> =
 type __VLS_AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
 
 declare function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+
+/**
+ * emit
+ */
+// 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) => infer R
+	? { [K in E as K extends string ? K : never]: (...args: A) => R; }
+	: never
+	: never;
+type __VLS_NormalizeEmits<T> = __VLS_Prettify<
+	__VLS_UnionToIntersection<
+		__VLS_ConstructorOverloads<T> & {
+			[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+		}
+	>
+>;
 `.trim();
 }
 exports.getTypesCode = getTypesCode;
-// TODO: not working for overloads > n (n = 8)
-// see: https://github.com/vuejs/language-tools/issues/60
-function genConstructorOverloads(name = 'ConstructorOverloads', nums) {
-    let code = '';
-    code += `type ${name}<T> =\n`;
-    if (nums === undefined) {
-        for (let i = 8; i >= 1; i--) {
-            gen(i);
-        }
-    }
-    else if (nums > 0) {
-        gen(nums);
-    }
-    code += `// 0\n`;
-    code += `{};\n`;
-    return code;
-    function gen(i) {
-        code += `// ${i}\n`;
-        code += `T extends {\n`;
-        for (let j = 1; j <= i; j++) {
-            code += `(event: infer E${j}, ...payload: infer P${j}): void;\n`;
-        }
-        code += `} ? (\n`;
-        for (let j = 1; j <= i; j++) {
-            if (j > 1)
-                code += '& ';
-            code += `(E${j} extends string ? { [K${j} in E${j}]: (...payload: P${j}) => void } : {})\n`;
-        }
-        code += `) :\n`;
-    }
-}
-exports.genConstructorOverloads = genConstructorOverloads;
 //# sourceMappingURL=globalTypes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "1.8.12",
+	"version": "1.8.14",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "a065fd7516de02f1804f3394d6e2e0511a1e67a5"
+	"gitHead": "5febf2694e80621a7b852464edc76b74f73a5cb6"
 }