@vue/language-core 2.1.10 → 2.2.2

package/index.d.ts

@@ -7,7 +7,6 @@ export * from './lib/types';
 export * from './lib/utils/parseSfc';
 export * from './lib/utils/ts';
 export * from './lib/virtualFile/vueFile';
-export * as scriptRanges from './lib/parsers/scriptRanges';
 export { tsCodegen } from './lib/plugins/vue-tsx';
 export * from './lib/utils/shared';
 export * from '@volar/language-core';

package/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsCodegen = exports.scriptRanges = void 0;
+exports.tsCodegen = void 0;
 __exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
@@ -24,7 +24,6 @@ __exportStar(require("./lib/types"), 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");
 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);

package/lib/codeFeatures.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/codeFeatures.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/codeFeatures.d.ts

@@ -0,0 +1,83 @@
+import type { VueCodeInformation } from '../types';
+declare const raw: {
+    all: {
+        verification: true;
+        completion: true;
+        semantic: true;
+        navigation: true;
+    };
+    none: {};
+    verification: {
+        verification: true;
+    };
+    completion: {
+        completion: true;
+    };
+    additionalCompletion: {
+        completion: {
+            isAdditional: true;
+        };
+    };
+    withoutCompletion: {
+        verification: true;
+        semantic: true;
+        navigation: true;
+    };
+    navigation: {
+        navigation: true;
+    };
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename: () => false;
+        };
+    };
+    navigationAndCompletion: {
+        navigation: true;
+        completion: true;
+    };
+    navigationAndAdditionalCompletion: {
+        navigation: true;
+        completion: {
+            isAdditional: true;
+        };
+    };
+    navigationAndVerification: {
+        navigation: true;
+        verification: true;
+    };
+    withoutNavigation: {
+        verification: true;
+        completion: true;
+        semantic: true;
+    };
+    withoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
+    withoutHighlightAndNavigation: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        completion: true;
+    };
+    withoutHighlightAndCompletion: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+    };
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+    };
+};
+export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
+export {};

package/lib/codegen/codeFeatures.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFeatures = void 0;
+const raw = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    none: {},
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    withoutCompletion: {
+        verification: true,
+        semantic: true,
+        navigation: true,
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: { shouldRename: () => false },
+    },
+    navigationAndCompletion: {
+        navigation: true,
+        completion: true,
+    },
+    navigationAndAdditionalCompletion: {
+        navigation: true,
+        completion: { isAdditional: true },
+    },
+    navigationAndVerification: {
+        navigation: true,
+        verification: true,
+    },
+    withoutNavigation: {
+        verification: true,
+        completion: true,
+        semantic: true,
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+exports.codeFeatures = raw;
+//# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/globalTypes.d.ts

@@ -1 +1,3 @@
-export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;
+import type { VueCompilerOptions } from '../types';
+export declare function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }: VueCompilerOptions): string;
+export declare function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }: VueCompilerOptions): string;

package/lib/codegen/globalTypes.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalTypesFileName = getGlobalTypesFileName;
 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>'}`;
+function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+    return [
+        lib,
+        target,
+        checkUnknownProps,
+        checkUnknownEvents,
+        checkUnknownComponents,
+    ].map(v => {
+        if (typeof v === 'boolean') {
+            return v ? 1 : 0;
+        }
+        return v;
+    }).join('_') + '.d.ts';
+}
+function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
     let text = ``;
     if (target < 3.5) {
         text += `
@@ -17,6 +32,7 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 	const __VLS_intrinsicElements: __VLS_IntrinsicElements;
 	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
 	const __VLS_unref: typeof import('${lib}').unref;
+	const __VLS_placeholder: any;
 
 	const __VLS_nativeElements = {
 		...{} as SVGElementTagNameMap,
@@ -36,14 +52,15 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 	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> =
+	type __VLS_WithComponent<N0 extends string, LocalComponents, Self, 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] } :
+		Self extends object ? { [K in N0]: Self } :
 		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 }'}
+		${checkUnknownComponents ? '{}' : '{ [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 :
@@ -55,6 +72,15 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		: true
 		: false
 		: false;
+	type __VLS_NormalizeComponentEvent<Props, Events, onEvent extends keyof Props, Event extends keyof Events, CamelizedEvent extends keyof Events> = (
+		__VLS_IsFunction<Props, onEvent> extends true
+			? Props
+			: __VLS_IsFunction<Events, Event> extends true
+				? { [K in onEvent]?: Events[Event] }
+				: __VLS_IsFunction<Events, CamelizedEvent> extends true
+					? { [K in onEvent]?: Events[CamelizedEvent] }
+					: Props
+	)${checkUnknownEvents ? '' : ' & Record<string, unknown>'};
 	// 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
@@ -83,25 +109,25 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
 		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
 	>>;
+	type __VLS_OmitStringIndex<T> = {
+		[K in keyof T as string extends K ? never : K]: T[K];
+	};
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
-	function __VLS_getVForSourceType(source: number): [number, number, number][];
-	function __VLS_getVForSourceType(source: string): [string, number, number][];
+	function __VLS_getVForSourceType(source: number): [number, number][];
+	function __VLS_getVForSourceType(source: string): [string, number][];
 	function __VLS_getVForSourceType<T extends any[]>(source: T): [
 		item: T[number],
-		key: number,
 		index: number,
 	][];
 	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,
+		index: number,
 	][];
 	// #3845
 	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,
+		index: number,
 	][];
 	function __VLS_getVForSourceType<T>(source: T): [
 		item: T[keyof T],
@@ -119,7 +145,6 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 			: __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;
 	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?: {
@@ -129,8 +154,8 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		} & { 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>'} } };
-	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
+	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (_: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [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/localTypes.d.ts

@@ -6,7 +6,7 @@ export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptio
     readonly PrettifyLocal: string;
     readonly OmitKeepDiscriminatedUnion: string;
     readonly WithDefaults: string;
-    readonly WithTemplateSlots: string;
+    readonly WithSlots: string;
     readonly PropsChildren: string;
     readonly TypePropsToOption: string;
     readonly OmitIndexSignature: string;

package/lib/codegen/localTypes.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalTypesGenerator = getLocalTypesGenerator;
 const shared_1 = require("../utils/shared");
-const common_1 = require("./common");
+const utils_1 = require("./utils");
 function getLocalTypesGenerator(compilerOptions, vueCompilerOptions) {
     const used = new Set();
     const OmitKeepDiscriminatedUnion = defineHelper(`__VLS_OmitKeepDiscriminatedUnion`, () => `
@@ -17,9 +17,9 @@ type __VLS_WithDefaults<P, D> = {
 		: 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 & {
+    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${utils_1.endOfLine}`);
+    const WithSlots = defineHelper(`__VLS_WithSlots`, () => `
+type __VLS_WithSlots<T, S> = T & {
 	new(): {
 		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
 		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
@@ -57,12 +57,12 @@ type __VLS_TypePropsToOption<T> = {
 		: { 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 OmitIndexSignature = defineHelper(`__VLS_OmitIndexSignature`, () => `type __VLS_OmitIndexSignature<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K]; }${utils_1.endOfLine}`);
     const helpers = {
         [PrettifyLocal.name]: PrettifyLocal,
         [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
         [WithDefaults.name]: WithDefaults,
-        [WithTemplateSlots.name]: WithTemplateSlots,
+        [WithSlots.name]: WithSlots,
         [PropsChildren.name]: PropsChildren,
         [TypePropsToOption.name]: TypePropsToOption,
         [OmitIndexSignature.name]: OmitIndexSignature,
@@ -76,7 +76,7 @@ type __VLS_TypePropsToOption<T> = {
         get PrettifyLocal() { return PrettifyLocal.name; },
         get OmitKeepDiscriminatedUnion() { return OmitKeepDiscriminatedUnion.name; },
         get WithDefaults() { return WithDefaults.name; },
-        get WithTemplateSlots() { return WithTemplateSlots.name; },
+        get WithSlots() { return WithSlots.name; },
         get PropsChildren() { return PropsChildren.name; },
         get TypePropsToOption() { return TypePropsToOption.name; },
         get OmitIndexSignature() { return OmitIndexSignature.name; },

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

@@ -0,0 +1,4 @@
+import type { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import type { ScriptCodegenOptions } from './index';
+export declare function generateBindings(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<import("../../types").Code, void, any>;

package/lib/codegen/script/binding.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBindings = generateBindings;
+const utils_1 = require("../utils");
+const component_1 = require("./component");
+const template_1 = require("./template");
+function* generateBindings(options, ctx, templateCodegenCtx) {
+    if (!options.sfc.scriptSetup || !options.scriptSetupRanges) {
+        return;
+    }
+    yield `const __VLS_bindings = {`;
+    if (ctx.bypassDefineComponent) {
+        yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+    }
+    const templateUsageVars = (0, template_1.getTemplateUsageVars)(options, ctx);
+    for (const [content, bindings] of [
+        [options.sfc.scriptSetup.content, options.scriptSetupRanges.bindings],
+        options.sfc.script && options.scriptRanges
+            ? [options.sfc.script.content, options.scriptRanges.bindings]
+            : ['', []],
+    ]) {
+        for (const { range } of bindings) {
+            const varName = content.slice(range.start, range.end);
+            if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessExternalVariables.has(varName)) {
+                continue;
+            }
+            const templateOffset = options.getGeneratedLength();
+            yield `${varName}: ${varName} as typeof `;
+            const scriptOffset = options.getGeneratedLength();
+            yield `${varName},${utils_1.newLine}`;
+            options.linkedCodeMappings.push({
+                sourceOffsets: [scriptOffset],
+                generatedOffsets: [templateOffset],
+                lengths: [varName.length],
+                data: undefined,
+            });
+        }
+    }
+    yield `}${utils_1.endOfLine}`;
+}
+//# sourceMappingURL=binding.js.map

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

@@ -1,7 +1,7 @@
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc } from '../../types';
 import type { ScriptCodegenContext } from './context';
-import { ScriptCodegenOptions } from './index';
+import type { 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, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/component.js

@@ -4,27 +4,27 @@ exports.generateComponent = generateComponent;
 exports.generateComponentSetupReturns = generateComponentSetupReturns;
 exports.generateEmitsOption = generateEmitsOption;
 exports.generatePropsOption = generatePropsOption;
-const common_1 = require("../common");
-const index_1 = require("./index");
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     if (options.sfc.script && options.scriptRanges?.exportDefault && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
         // use defineComponent() from user space code if it exist
-        yield (0, common_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, index_1.codeFeatures.all);
-        yield `{${common_1.newLine}`;
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, codeFeatures_1.codeFeatures.all);
+        yield `{${utils_1.newLine}`;
     }
     else {
-        yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+        yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
     }
-    yield `setup() {${common_1.newLine}`;
-    yield `return {${common_1.newLine}`;
+    yield `setup() {${utils_1.newLine}`;
+    yield `return {${utils_1.newLine}`;
     if (ctx.bypassDefineComponent) {
         yield* generateComponentSetupReturns(scriptSetupRanges);
     }
-    if (scriptSetupRanges.expose.define) {
-        yield `...__VLS_exposed,${common_1.newLine}`;
+    if (scriptSetupRanges.defineExpose) {
+        yield `...__VLS_exposed,${utils_1.newLine}`;
     }
-    yield `}${common_1.endOfLine}`;
-    yield `},${common_1.newLine}`;
+    yield `}${utils_1.endOfLine}`;
+    yield `},${utils_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
         const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
         for (const code of emitOptionCodes) {
@@ -34,26 +34,26 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     }
     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);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, codeFeatures_1.codeFeatures.all);
     }
-    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?.templateRefs.size) {
+        yield `__typeRefs: {} as __VLS_TemplateRefs,${utils_1.newLine}`;
     }
     if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.singleRootElType) {
-        yield `__typeEl: {} as __VLS_TemplateResult['rootEl'],${common_1.newLine}`;
+        yield `__typeEl: {} as __VLS_RootEl,${utils_1.newLine}`;
     }
     yield `})`;
 }
 function* generateComponentSetupReturns(scriptSetupRanges) {
     // fill $props
-    if (scriptSetupRanges.props.define) {
+    if (scriptSetupRanges.defineProps) {
         // NOTE: defineProps is inaccurate for $props
-        yield `$props: __VLS_makeOptional(${scriptSetupRanges.props.name ?? `__VLS_props`}),${common_1.newLine}`;
-        yield `...${scriptSetupRanges.props.name ?? `__VLS_props`},${common_1.newLine}`;
+        yield `$props: __VLS_makeOptional(${scriptSetupRanges.defineProps.name ?? `__VLS_props`}),${utils_1.newLine}`;
+        yield `...${scriptSetupRanges.defineProps.name ?? `__VLS_props`},${utils_1.newLine}`;
     }
     // fill $emit
-    if (scriptSetupRanges.emits.define) {
-        yield `$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
+    if (scriptSetupRanges.defineEmits) {
+        yield `$emit: ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'},${utils_1.newLine}`;
     }
 }
 function* generateEmitsOption(options, scriptSetupRanges) {
@@ -64,10 +64,10 @@ function* generateEmitsOption(options, scriptSetupRanges) {
             typeOptionType: `__VLS_ModelEmit`,
         });
     }
-    if (scriptSetupRanges.emits.define) {
-        const { typeArg, hasUnionTypeArg } = scriptSetupRanges.emits.define;
+    if (scriptSetupRanges.defineEmits) {
+        const { name, typeArg, hasUnionTypeArg } = scriptSetupRanges.defineEmits;
         codes.push({
-            optionExp: `{} as __VLS_NormalizeEmits<typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}>`,
+            optionExp: `{} as __VLS_NormalizeEmits<typeof ${name ?? '__VLS_emit'}>`,
             typeOptionType: typeArg && !hasUnionTypeArg
                 ? `__VLS_Emit`
                 : undefined,
@@ -77,7 +77,7 @@ function* generateEmitsOption(options, scriptSetupRanges) {
         if (codes.length === 1) {
             yield `__typeEmits: {} as `;
             yield codes[0].typeOptionType;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
         else if (codes.length >= 2) {
             yield `__typeEmits: {} as `;
@@ -86,23 +86,23 @@ function* generateEmitsOption(options, scriptSetupRanges) {
                 yield ` & `;
                 yield codes[i].typeOptionType;
             }
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
     }
     else if (codes.every(code => code.optionExp)) {
         if (codes.length === 1) {
             yield `emits: `;
             yield codes[0].optionExp;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
         else if (codes.length >= 2) {
-            yield `emits: {${common_1.newLine}`;
+            yield `emits: {${utils_1.newLine}`;
             for (const code of codes) {
                 yield `...`;
                 yield code.optionExp;
-                yield `,${common_1.newLine}`;
+                yield `,${utils_1.newLine}`;
             }
-            yield `},${common_1.newLine}`;
+            yield `},${utils_1.newLine}`;
         }
     }
 }
@@ -112,22 +112,22 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
         codes.push({
             optionExp: [
                 `{} as `,
-                scriptSetupRanges.props.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
+                scriptSetupRanges.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
                 `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
-                scriptSetupRanges.props.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
+                scriptSetupRanges.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
             ].join(''),
             typeOptionExp: `{} as __VLS_PublicProps`,
         });
     }
-    if (scriptSetupRanges.props.define?.arg) {
-        const { arg } = scriptSetupRanges.props.define;
+    if (scriptSetupRanges.defineProps?.arg) {
+        const { arg } = scriptSetupRanges.defineProps;
         codes.push({
-            optionExp: (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation),
+            optionExp: (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.navigation),
             typeOptionExp: undefined,
         });
     }
     if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
-        let attrsType = `__VLS_TemplateResult['attrs']`;
+        let attrsType = `Partial<__VLS_InheritedAttrs>`;
         if (hasEmitsOption) {
             attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
         }
@@ -142,37 +142,37 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
         });
     }
     const useTypeOption = options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionExp);
-    const useOption = !useTypeOption || scriptSetupRanges.props.withDefaults;
+    const useOption = !useTypeOption || scriptSetupRanges.withDefaults;
     if (useTypeOption) {
         if (codes.length === 1) {
             yield `__typeProps: `;
             yield codes[0].typeOptionExp;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
         else if (codes.length >= 2) {
-            yield `__typeProps: {${common_1.newLine}`;
+            yield `__typeProps: {${utils_1.newLine}`;
             for (const { typeOptionExp } of codes) {
                 yield `...`;
                 yield typeOptionExp;
-                yield `,${common_1.newLine}`;
+                yield `,${utils_1.newLine}`;
             }
-            yield `},${common_1.newLine}`;
+            yield `},${utils_1.newLine}`;
         }
     }
     if (useOption) {
         if (codes.length === 1) {
             yield `props: `;
             yield codes[0].optionExp;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
         else if (codes.length >= 2) {
-            yield `props: {${common_1.newLine}`;
+            yield `props: {${utils_1.newLine}`;
             for (const { optionExp } of codes) {
                 yield `...`;
                 yield optionExp;
-                yield `,${common_1.newLine}`;
+                yield `,${utils_1.newLine}`;
             }
-            yield `},${common_1.newLine}`;
+            yield `},${utils_1.newLine}`;
         }
     }
 }

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

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