@vue/language-core 2.0.28 → 2.1.0

package/lib/codegen/script/context.js

@@ -1,99 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createScriptCodegenContext = createScriptCodegenContext;
-const shared_1 = require("../../utils/shared");
-const common_1 = require("../common");
+const localTypes_1 = require("../localTypes");
 function createScriptCodegenContext(options) {
-    const helperTypes = {
-        OmitKeepDiscriminatedUnion: {
-            get name() {
-                this.used = true;
-                return `__VLS_OmitKeepDiscriminatedUnion`;
-            },
-            get code() {
-                return `type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
-					? Pick<T, Exclude<keyof T, K>>
-					: never;`;
-            },
-        },
-        WithDefaults: {
-            get name() {
-                this.used = true;
-                return `__VLS_WithDefaults`;
-            },
-            get code() {
-                return `type __VLS_WithDefaults<P, D> = {
-					[K in keyof Pick<P, keyof P>]: K extends keyof D
-						? ${helperTypes.Prettify.name}<P[K] & { default: D[K]}>
-						: P[K]
-				};`;
-            },
-        },
-        Prettify: {
-            get name() {
-                this.used = true;
-                return `__VLS_Prettify`;
-            },
-            get code() {
-                return `type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};`;
-            },
-        },
-        WithTemplateSlots: {
-            get name() {
-                this.used = true;
-                return `__VLS_WithTemplateSlots`;
-            },
-            get code() {
-                return `type __VLS_WithTemplateSlots<T, S> = T & {
-					new(): {
-						${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: S;
-						${options.vueCompilerOptions.jsxSlots ? `$props: ${helperTypes.PropsChildren.name}<S>;` : ''}
-					}
-				};`;
-            },
-        },
-        PropsChildren: {
-            get name() {
-                this.used = true;
-                return `__VLS_PropsChildren`;
-            },
-            get code() {
-                return `type __VLS_PropsChildren<S> = {
-					[K in keyof (
-						boolean extends (
-							// @ts-ignore
-							JSX.ElementChildrenAttribute extends never
-								? true
-								: false
-						)
-							? never
-							// @ts-ignore
-							: JSX.ElementChildrenAttribute
-					)]?: S;
-				};`;
-            },
-        },
-        TypePropsToOption: {
-            get name() {
-                this.used = true;
-                return `__VLS_TypePropsToOption`;
-            },
-            get code() {
-                return options.compilerOptions.exactOptionalPropertyTypes ?
-                    `type __VLS_TypePropsToOption<T> = {
-						[K in keyof T]-?: {} extends Pick<T, K>
-							? { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]> }
-							: { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]>, required: true }
-					};` :
-                    `type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-					type __VLS_TypePropsToOption<T> = {
-						[K in keyof T]-?: {} extends Pick<T, K>
-							? { type: import('${options.vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
-							: { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]>, required: true }
-					};`;
-            },
-        },
-    };
+    const localTypes = (0, localTypes_1.getLocalTypesGenerator)(options.compilerOptions, options.vueCompilerOptions);
+    const inlayHints = [];
     return {
         generatedTemplate: false,
         generatedPropsType: false,
@@ -103,21 +14,8 @@ function createScriptCodegenContext(options) {
             ...options.scriptRanges?.bindings.map(range => options.sfc.script.content.substring(range.start, range.end)) ?? [],
             ...options.scriptSetupRanges?.bindings.map(range => options.sfc.scriptSetup.content.substring(range.start, range.end)) ?? [],
         ]),
-        helperTypes,
-        generateHelperTypes,
+        localTypes,
+        inlayHints,
     };
-    function* generateHelperTypes() {
-        let shouldCheck = true;
-        while (shouldCheck) {
-            shouldCheck = false;
-            for (const helperType of Object.values(helperTypes)) {
-                if (helperType.used && !helperType.generated) {
-                    shouldCheck = true;
-                    helperType.generated = true;
-                    yield common_1.newLine + helperType.code + common_1.newLine;
-                }
-            }
-        }
-    }
 }
 //# sourceMappingURL=context.js.map

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

@@ -4,6 +4,7 @@ import type { ScriptRanges } from '../../parsers/scriptRanges';
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
+import { ScriptCodegenContext } from './context';
 export declare const codeFeatures: {
     all: VueCodeInformation;
     none: VueCodeInformation;
@@ -23,8 +24,8 @@ export interface ScriptCodegenOptions {
     templateCodegen: TemplateCodegenContext & {
         codes: Code[];
     } | undefined;
-    globalTypes: boolean;
+    edited: boolean;
     getGeneratedLength: () => number;
     linkedCodeMappings: Mapping[];
 }
-export declare function generateScript(options: ScriptCodegenOptions): Generator<Code>;
+export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;

package/lib/codegen/script/index.js

@@ -4,7 +4,6 @@ exports.codeFeatures = void 0;
 exports.generateScript = generateScript;
 const common_1 = require("../common");
 const context_1 = require("./context");
-const globalTypes_1 = require("./globalTypes");
 const scriptSetup_1 = require("./scriptSetup");
 const src_1 = require("./src");
 const template_1 = require("./template");
@@ -32,7 +31,7 @@ exports.codeFeatures = {
 };
 function* generateScript(options) {
     const ctx = (0, context_1.createScriptCodegenContext)(options);
-    yield `/* __placeholder__ */${common_1.newLine}`;
+    yield `/// <reference types="${options.vueCompilerOptions.lib}/__globalTypes_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}" />${common_1.newLine}`;
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script, options.sfc.script.src);
     }
@@ -54,47 +53,42 @@ function* generateScript(options) {
             }
         }
         else if (exportDefault && isExportRawObject && options.vueCompilerOptions.optionsWrapper.length) {
+            ctx.inlayHints.push({
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.start,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length
+                    ? options.vueCompilerOptions.optionsWrapper[0]
+                    : '[Missing optionsWrapper[0]]',
+                tooltip: [
+                    'This is virtual code that is automatically wrapped for type support, it does not affect your runtime behavior, you can customize it via `vueCompilerOptions.optionsWrapper` option in tsconfig / jsconfig.',
+                    'To hide it, you can set `"vue.inlayHints.optionsWrapper": false` in IDE settings.',
+                ].join('\n\n'),
+            }, {
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.end,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length >= 2
+                    ? options.vueCompilerOptions.optionsWrapper[1]
+                    : '[Missing optionsWrapper[1]]',
+            });
             yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
             yield options.vueCompilerOptions.optionsWrapper[0];
-            yield [
-                '',
-                'script',
-                exportDefault.expression.start,
-                {
-                    __hint: {
-                        setting: 'vue.inlayHints.optionsWrapper',
-                        label: options.vueCompilerOptions.optionsWrapper.length
-                            ? options.vueCompilerOptions.optionsWrapper[0]
-                            : '[Missing optionsWrapper]',
-                        tooltip: [
-                            'This is virtual code that is automatically wrapped for type support, it does not affect your runtime behavior, you can customize it via `vueCompilerOptions.optionsWrapper` option in tsconfig / jsconfig.',
-                            'To hide it, you can set `"vue.inlayHints.optionsWrapper": false` in IDE settings.',
-                        ].join('\n\n'),
-                    }
-                },
-            ];
             yield (0, common_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.start, exportDefault.expression.end, exports.codeFeatures.all);
-            yield [
-                '',
-                'script',
-                exportDefault.expression.end,
-                {
-                    __hint: {
-                        setting: 'vue.inlayHints.optionsWrapper',
-                        label: options.vueCompilerOptions.optionsWrapper.length === 2
-                            ? options.vueCompilerOptions.optionsWrapper[1]
-                            : '[Missing optionsWrapper]',
-                        tooltip: '',
-                    }
-                },
-            ];
             yield options.vueCompilerOptions.optionsWrapper[1];
             yield (0, common_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, exports.codeFeatures.all);
         }
         else if (classBlockEnd !== undefined) {
-            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, exports.codeFeatures.all);
-            yield* (0, template_1.generateTemplate)(options, ctx, true);
-            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, exports.codeFeatures.all);
+            if (options.vueCompilerOptions.skipTemplateCodegen) {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+            else {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, exports.codeFeatures.all);
+                yield `__VLS_template = () => {`;
+                yield* (0, template_1.generateTemplate)(options, ctx, true);
+                yield `},${common_1.newLine}`;
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
         }
         else {
             yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
@@ -108,30 +102,20 @@ function* generateScript(options) {
     yield `;`;
     if (options.sfc.scriptSetup) {
         // #4569
-        yield [
-            '',
-            'scriptSetup',
-            options.sfc.scriptSetup.content.length,
-            exports.codeFeatures.verification,
-        ];
+        yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
     }
     yield common_1.newLine;
-    if (options.globalTypes) {
-        yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions);
-    }
-    yield* ctx.generateHelperTypes();
-    yield `\ntype __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${common_1.endOfLine}`;
     if (!ctx.generatedTemplate) {
         yield* (0, template_1.generateTemplate)(options, ctx, false);
     }
+    if (options.edited) {
+        yield `type __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${common_1.endOfLine}`;
+    }
+    yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
     if (options.sfc.scriptSetup) {
-        yield [
-            '',
-            'scriptSetup',
-            options.sfc.scriptSetup.content.length,
-            exports.codeFeatures.verification,
-        ];
+        yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
     }
+    return ctx;
 }
 function* generateDefineProp(options, scriptSetup) {
     const definePropProposalA = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';

package/lib/codegen/script/internalComponent.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 generateInternalComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/script/internalComponent.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInternalComponent = generateInternalComponent;
 const common_1 = require("../common");
 const component_1 = require("./component");
+const index_1 = require("./index");
 const template_1 = require("./template");
 function* generateInternalComponent(options, ctx, templateCodegenCtx) {
     if (options.sfc.scriptSetup && options.scriptSetupRanges) {
-        yield `let __VLS_defineComponent!: typeof import('${options.vueCompilerOptions.lib}').defineComponent${common_1.endOfLine}`;
-        yield `const __VLS_internalComponent = __VLS_defineComponent({${common_1.newLine}`;
+        yield `const __VLS_internalComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
         yield `setup() {${common_1.newLine}`;
         yield `return {${common_1.newLine}`;
         if (ctx.bypassDefineComponent) {
@@ -40,11 +40,19 @@ function* generateInternalComponent(options, ctx, templateCodegenCtx) {
         }
         yield `}${common_1.endOfLine}`; // return {
         yield `},${common_1.newLine}`; // setup() {
+        if (options.vueCompilerOptions.target >= 3.5) {
+            yield `__typeRefs: {} as __VLS_Refs,${common_1.newLine}`;
+        }
         if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
-            yield* (0, component_1.generateScriptSetupOptions)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+            const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.sfc.scriptSetup, options.scriptSetupRanges)];
+            for (const code of emitOptionCodes) {
+                yield code;
+            }
+            yield* (0, component_1.generatePropsOption)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges, !!emitOptionCodes.length, false);
         }
-        if (options.sfc.script && options.scriptRanges) {
-            yield* (0, component_1.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);
         }
         yield `})${common_1.endOfLine}`; // defineComponent {
     }

package/lib/codegen/script/scriptSetup.js

@@ -42,20 +42,23 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
         }
         yield `>(${common_1.newLine}`
             + `	__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'],${common_1.newLine}`
-            + `	__VLS_ctx?: ${ctx.helperTypes.Prettify.name}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__VLS_ctx?: ${ctx.localTypes.PrettifyLocal}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
             + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${common_1.newLine}`
             + `	__VLS_setup = (async () => {${common_1.newLine}`;
         yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined, definePropMirrors);
-        const emitTypes = ['__VLS_ModelEmitsType'];
+        const emitTypes = [];
         if (scriptSetupRanges.emits.define) {
-            emitTypes.unshift(`typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}`);
+            emitTypes.push(`typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}`);
+        }
+        if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+            emitTypes.push(`__VLS_ModelEmitsType`);
         }
         yield `		return {} as {${common_1.newLine}`
-            + `			props: ${ctx.helperTypes.Prettify.name}<typeof __VLS_functionalComponentProps & __VLS_PublicProps> & __VLS_BuiltInPublicProps,${common_1.newLine}`
+            + `			props: ${ctx.localTypes.PrettifyLocal}<typeof __VLS_functionalComponentProps & __VLS_PublicProps> & __VLS_BuiltInPublicProps,${common_1.newLine}`
             + `			expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,${common_1.newLine}`
             + `			attrs: any,${common_1.newLine}`
-            + `			slots: ReturnType<typeof __VLS_template>,${common_1.newLine}`
-            + `			emit: ${emitTypes.join(' & ')},${common_1.newLine}`
+            + `			slots: __VLS_Slots,${common_1.newLine}`
+            + `			emit: ${emitTypes.length ? emitTypes.join(' & ') : `{}`},${common_1.newLine}`
             + `		}${common_1.endOfLine}`;
         yield `	})(),${common_1.newLine}`; // __VLS_setup = (async () => {
         yield `) => ({} as import('${options.vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`;
@@ -74,16 +77,16 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
     }
     if (ctx.scriptSetupGeneratedOffset !== undefined) {
         for (const defineProp of scriptSetupRanges.defineProp) {
-            if (!defineProp.name) {
+            if (!defineProp.localName) {
                 continue;
             }
-            const propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
-            const propMirror = definePropMirrors.get(propName);
+            const [_, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            const propMirror = definePropMirrors.get(localName);
             if (propMirror !== undefined) {
                 options.linkedCodeMappings.push({
-                    sourceOffsets: [defineProp.name.start + ctx.scriptSetupGeneratedOffset],
+                    sourceOffsets: [defineProp.localName.start + ctx.scriptSetupGeneratedOffset],
                     generatedOffsets: [propMirror],
-                    lengths: [defineProp.name.end - defineProp.name.start],
+                    lengths: [defineProp.localName.end - defineProp.localName.start],
                     data: undefined,
                 });
             }
@@ -94,7 +97,7 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     if (options.vueCompilerOptions.target >= 3.3) {
         yield `const { `;
         for (const macro of Object.keys(options.vueCompilerOptions.macros)) {
-            if (!ctx.bindingNames.has(macro)) {
+            if (!ctx.bindingNames.has(macro) && macro !== 'templateRef') {
                 yield macro + `, `;
             }
         }
@@ -188,6 +191,39 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
             ]);
         }
     }
+    if (scriptSetupRanges.cssModules.length) {
+        for (const { exp, arg } of scriptSetupRanges.cssModules) {
+            if (arg) {
+                setupCodeModifies.push([
+                    [
+                        ` as Omit<__VLS_StyleModules, '$style'>[`,
+                        (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.all),
+                        `]`
+                    ],
+                    exp.end,
+                    exp.end
+                ]);
+            }
+            else {
+                setupCodeModifies.push([
+                    [
+                        ` as __VLS_StyleModules[`,
+                        ['', scriptSetup.name, exp.start, index_1.codeFeatures.verification],
+                        `'$style'`,
+                        ['', scriptSetup.name, exp.end, index_1.codeFeatures.verification],
+                        `]`
+                    ],
+                    exp.end,
+                    exp.end
+                ]);
+            }
+        }
+    }
+    for (const { define } of scriptSetupRanges.templateRefs) {
+        if (define?.arg) {
+            setupCodeModifies.push([[`<__VLS_Refs[${scriptSetup.content.slice(define.arg.start, define.arg.end)}], keyof __VLS_Refs>`], define.arg.start - 1, define.arg.start - 1]);
+        }
+    }
     setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
     if (setupCodeModifies.length) {
         yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.importSectionEndOffset, setupCodeModifies[0][1], index_1.codeFeatures.all);
@@ -216,14 +252,17 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     }
     yield* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors);
     yield* generateModelEmits(options, scriptSetup, scriptSetupRanges);
+    yield* generateStyleModules(options, ctx);
     yield* (0, template_1.generateTemplate)(options, ctx, false);
+    yield `type __VLS_Refs = typeof __VLS_templateResult['refs']${common_1.endOfLine}`;
+    yield `type __VLS_Slots = typeof __VLS_templateResult['slots']${common_1.endOfLine}`;
     if (syntax) {
         if (!options.vueCompilerOptions.skipTemplateCodegen && (options.templateCodegen?.hasSlot || scriptSetupRanges?.slots.define)) {
             yield `const __VLS_component = `;
             yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
             yield common_1.endOfLine;
             yield `${syntax} `;
-            yield `{} as ${ctx.helperTypes.WithTemplateSlots.name}<typeof __VLS_component, ReturnType<typeof __VLS_template>>${common_1.endOfLine}`;
+            yield `{} as ${ctx.localTypes.WithTemplateSlots}<typeof __VLS_component, __VLS_Slots>${common_1.endOfLine}`;
         }
         else {
             yield `${syntax} `;
@@ -233,10 +272,9 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     }
 }
 function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors) {
-    yield `const __VLS_fnComponent = `
-        + `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+    yield `const __VLS_fnComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
     if (scriptSetupRanges.props.define?.arg) {
-        yield `	props: `;
+        yield `props: `;
         yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end, index_1.codeFeatures.navigation);
         yield `,${common_1.newLine}`;
     }
@@ -251,20 +289,24 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             : `globalThis.JSX.IntrinsicAttributes;`}`;
     yield common_1.endOfLine;
     yield `let __VLS_functionalComponentProps!: `;
-    yield `${ctx.helperTypes.OmitKeepDiscriminatedUnion.name}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
+    yield `${ctx.localTypes.OmitKeepDiscriminatedUnion}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
     yield common_1.endOfLine;
     if (scriptSetupRanges.defineProp.length) {
         yield `const __VLS_defaults = {${common_1.newLine}`;
         for (const defineProp of scriptSetupRanges.defineProp) {
             if (defineProp.defaultValue) {
-                if (defineProp.name) {
-                    yield scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+                if (defineProp.name || defineProp.isModel) {
+                    yield propName;
+                }
+                else if (defineProp.localName) {
+                    yield localName;
                 }
                 else {
-                    yield `modelValue`;
+                    continue;
                 }
                 yield `: `;
-                yield scriptSetup.content.substring(defineProp.defaultValue.start, defineProp.defaultValue.end);
+                yield getRangeName(scriptSetup, defineProp.defaultValue);
                 yield `,${common_1.newLine}`;
             }
         }
@@ -276,7 +318,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             yield ` & `;
         }
         ctx.generatedPropsType = true;
-        yield `${ctx.helperTypes.PropsChildren.name}<typeof __VLS_slots>`;
+        yield `${ctx.localTypes.PropsChildren}<typeof __VLS_slots>`;
     }
     if (scriptSetupRanges.defineProp.length) {
         if (ctx.generatedPropsType) {
@@ -285,32 +327,32 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
         ctx.generatedPropsType = true;
         yield `{${common_1.newLine}`;
         for (const defineProp of scriptSetupRanges.defineProp) {
-            let propName = 'modelValue';
-            if (defineProp.name && defineProp.nameIsString) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            if (defineProp.isModel && !defineProp.name) {
+                yield propName;
+            }
+            else if (defineProp.name) {
                 // renaming support
                 yield (0, common_1.generateSfcBlockSection)(scriptSetup, defineProp.name.start, defineProp.name.end, index_1.codeFeatures.navigation);
-                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
-                propName = propName.replace(/['"]+/g, '');
             }
-            else if (defineProp.name) {
-                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
-                definePropMirrors.set(propName, options.getGeneratedLength());
-                yield propName;
+            else if (defineProp.localName) {
+                definePropMirrors.set(localName, options.getGeneratedLength());
+                yield localName;
             }
             else {
-                yield propName;
+                continue;
             }
             yield defineProp.required
                 ? `: `
                 : `?: `;
-            yield* generateDefinePropType(scriptSetup, propName, defineProp);
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineProp);
             yield `,${common_1.newLine}`;
             if (defineProp.modifierType) {
                 let propModifierName = 'modelModifiers';
                 if (defineProp.name) {
-                    propModifierName = `${scriptSetup.content.substring(defineProp.name.start + 1, defineProp.name.end - 1)}Modifiers`;
+                    propModifierName = `${getRangeName(scriptSetup, defineProp.name, true)}Modifiers`;
                 }
-                const modifierType = scriptSetup.content.substring(defineProp.modifierType.start, defineProp.modifierType.end);
+                const modifierType = getRangeName(scriptSetup, defineProp.modifierType);
                 definePropMirrors.set(propModifierName, options.getGeneratedLength());
                 yield `${propModifierName}?: Record<${modifierType}, true>,${common_1.endOfLine}`;
             }
@@ -330,46 +372,68 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
     yield common_1.endOfLine;
 }
 function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
-    yield `type __VLS_ModelEmitsType = `;
-    if (scriptSetupRanges.defineProp.filter(p => p.isModel).length) {
-        if (options.vueCompilerOptions.target < 3.5) {
-            yield `typeof __VLS_modelEmitsType${common_1.endOfLine}`;
-            yield `const __VLS_modelEmitsType = (await import('${options.vueCompilerOptions.lib}')).defineEmits<`;
-        }
-        yield `{${common_1.newLine}`;
-        for (const defineProp of scriptSetupRanges.defineProp) {
-            if (!defineProp.isModel) {
-                continue;
+    const defineModels = scriptSetupRanges.defineProp.filter(p => p.isModel);
+    if (defineModels.length) {
+        const generateDefineModels = function* () {
+            for (const defineModel of defineModels) {
+                const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
+                yield `'update:${propName}': [${propName}:`;
+                yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
+                yield `]${common_1.endOfLine}`;
             }
-            let propName = 'modelValue';
-            if (defineProp.name) {
-                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
-                propName = propName.replace(/['"]+/g, '');
-            }
-            yield `'update:${propName}': [${propName}:`;
-            yield* generateDefinePropType(scriptSetup, propName, defineProp);
-            yield `]${common_1.endOfLine}`;
+        };
+        if (options.vueCompilerOptions.target >= 3.5) {
+            yield `type __VLS_ModelEmitsType = {${common_1.newLine}`;
+            yield* generateDefineModels();
+            yield `}${common_1.endOfLine}`;
         }
-        yield `}`;
-        if (options.vueCompilerOptions.target < 3.5) {
-            yield `>()`;
+        else {
+            yield `const __VLS_modelEmitsType = (await import('${options.vueCompilerOptions.lib}')).defineEmits<{${common_1.newLine}`;
+            yield* generateDefineModels();
+            yield `}>()${common_1.endOfLine}`;
+            yield `type __VLS_ModelEmitsType = typeof __VLS_modelEmitsType${common_1.endOfLine}`;
         }
     }
-    else {
-        yield `{}`;
+}
+function* generateStyleModules(options, ctx) {
+    const styles = options.sfc.styles.filter(style => style.module);
+    if (!styles.length) {
+        return;
     }
+    yield `type __VLS_StyleModules = {${common_1.newLine}`;
+    for (let i = 0; i < styles.length; i++) {
+        const style = styles[i];
+        const { name, offset } = style.module;
+        if (offset) {
+            yield [
+                name,
+                'main',
+                offset + 1,
+                index_1.codeFeatures.all
+            ];
+        }
+        else {
+            yield name;
+        }
+        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
+        for (const className of style.classNames) {
+            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
+        }
+        yield `>${common_1.endOfLine}`;
+    }
+    yield `}`;
     yield common_1.endOfLine;
 }
-function* generateDefinePropType(scriptSetup, propName, defineProp) {
+function* generateDefinePropType(scriptSetup, propName, localName, defineProp) {
     if (defineProp.type) {
         // Infer from defineProp<T>
-        yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+        yield getRangeName(scriptSetup, defineProp.type);
     }
-    else if ((defineProp.name && defineProp.nameIsString) || !defineProp.nameIsString) {
+    else if (defineProp.runtimeType && localName) {
         // Infer from actual prop declaration code 
-        yield `NonNullable<typeof ${propName}['value']>`;
+        yield `typeof ${localName}['value']`;
     }
-    else if (defineProp.defaultValue) {
+    else if (defineProp.defaultValue && propName) {
         // Infer from defineProp({default: T})
         yield `typeof __VLS_defaults['${propName}']`;
     }
@@ -377,4 +441,22 @@ function* generateDefinePropType(scriptSetup, propName, defineProp) {
         yield `any`;
     }
 }
+function getPropAndLocalName(scriptSetup, defineProp) {
+    const localName = defineProp.localName
+        ? getRangeName(scriptSetup, defineProp.localName)
+        : undefined;
+    let propName = defineProp.name
+        ? getRangeName(scriptSetup, defineProp.name)
+        : defineProp.isModel
+            ? 'modelValue'
+            : localName;
+    if (defineProp.name) {
+        propName = propName.replace(/['"]+/g, '');
+    }
+    return [propName, localName];
+}
+function getRangeName(scriptSetup, range, unwrap = false) {
+    const offset = unwrap ? 1 : 0;
+    return scriptSetup.content.substring(range.start + offset, range.end - offset);
+}
 //# sourceMappingURL=scriptSetup.js.map