@vue/language-core 2.0.26-alpha.2 → 2.0.28

package/index.d.ts

@@ -1,5 +1,5 @@
 export * from './lib/codegen/template';
-export * from './lib/languageModule';
+export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
 export * from './lib/virtualFile/vueFile';

package/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = exports.scriptRanges = void 0;
 __exportStar(require("./lib/codegen/template"), exports);
-__exportStar(require("./lib/languageModule"), exports);
+__exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);

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

@@ -7,3 +7,5 @@ export declare function generateComponent(options: ScriptCodegenOptions, ctx: Sc
 export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
 export declare function generateScriptOptions(script: NonNullable<Sfc['script']>, scriptRanges: ScriptRanges): Generator<Code>;
 export declare function generateScriptSetupOptions(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generatePropsOption(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code, void, unknown>;
+export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/component.js

@@ -4,6 +4,8 @@ exports.generateComponent = generateComponent;
 exports.generateComponentSetupReturns = generateComponentSetupReturns;
 exports.generateScriptOptions = generateScriptOptions;
 exports.generateScriptSetupOptions = generateScriptSetupOptions;
+exports.generatePropsOption = generatePropsOption;
+exports.generateEmitsOption = generateEmitsOption;
 const common_1 = require("../common");
 const index_1 = require("./index");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
@@ -51,58 +53,72 @@ function* generateScriptOptions(script, scriptRanges) {
     }
 }
 function* generateScriptSetupOptions(options, ctx, scriptSetup, scriptSetupRanges) {
-    const propsCodegens = [];
-    if (ctx.generatedPropsType) {
-        propsCodegens.push(function* () {
-            yield `{} as `;
-            if (scriptSetupRanges.props.withDefaults?.arg) {
-                yield `${ctx.helperTypes.WithDefaults.name}<`;
-            }
-            yield `${ctx.helperTypes.TypePropsToOption.name}<`;
-            yield `__VLS_PublicProps>`;
-            if (scriptSetupRanges.props.withDefaults?.arg) {
-                yield `, typeof __VLS_withDefaultsArg>`;
-            }
-        });
-    }
-    if (scriptSetupRanges.props.define?.arg) {
-        const { arg } = scriptSetupRanges.props.define;
-        propsCodegens.push(function* () {
-            yield (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation);
-        });
+    yield* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges);
+    yield* generateEmitsOption(options, scriptSetup, scriptSetupRanges);
+}
+function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (options.vueCompilerOptions.target >= 3.5 && ctx.generatedPropsType) {
+        yield `__typeProps: {} as __VLS_PublicProps,${common_1.newLine}`;
     }
-    if (propsCodegens.length === 1) {
-        yield `props: `;
-        for (const generate of propsCodegens) {
-            yield* generate();
+    if (options.vueCompilerOptions.target < 3.5 || !ctx.generatedPropsType || scriptSetupRanges.props.withDefaults) {
+        const codegens = [];
+        if (ctx.generatedPropsType) {
+            codegens.push(function* () {
+                yield `{} as `;
+                if (scriptSetupRanges.props.withDefaults?.arg) {
+                    yield `${ctx.helperTypes.WithDefaults.name}<`;
+                }
+                yield `${ctx.helperTypes.TypePropsToOption.name}<`;
+                yield `__VLS_PublicProps>`;
+                if (scriptSetupRanges.props.withDefaults?.arg) {
+                    yield `, typeof __VLS_withDefaultsArg>`;
+                }
+            });
         }
-        yield `,${common_1.newLine}`;
-    }
-    else if (propsCodegens.length >= 2) {
-        yield `props: {${common_1.newLine}`;
-        for (const generate of propsCodegens) {
-            yield `...`;
-            yield* generate();
+        if (scriptSetupRanges.props.define?.arg) {
+            const { arg } = scriptSetupRanges.props.define;
+            codegens.push(function* () {
+                yield (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation);
+            });
+        }
+        if (codegens.length === 1) {
+            yield `props: `;
+            for (const generate of codegens) {
+                yield* generate();
+            }
             yield `,${common_1.newLine}`;
         }
-        yield `},${common_1.newLine}`;
+        else if (codegens.length >= 2) {
+            yield `props: {${common_1.newLine}`;
+            for (const generate of codegens) {
+                yield `...`;
+                yield* generate();
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
+        }
+    }
+}
+function* generateEmitsOption(options, scriptSetup, scriptSetupRanges) {
+    if (!scriptSetupRanges.emits.define && !scriptSetupRanges.defineProp.some(p => p.isModel)) {
+        return;
     }
-    if (scriptSetupRanges.defineProp.filter(p => p.isModel).length || scriptSetupRanges.emits.define) {
-        yield `emits: ({} as __VLS_NormalizeEmits<typeof __VLS_modelEmitsType`;
-        if (scriptSetupRanges.emits.define) {
+    if (options.vueCompilerOptions.target < 3.5 || scriptSetupRanges.emits.define?.arg || scriptSetupRanges.emits.define?.hasUnionTypeArg) {
+        yield `emits: ({} as __VLS_NormalizeEmits<__VLS_ModelEmitsType`;
+        if (scriptSetupRanges?.emits.define) {
             yield ` & typeof `;
             yield scriptSetupRanges.emits.name ?? '__VLS_emit';
         }
         yield `>),${common_1.newLine}`;
     }
-    if (options.vueCompilerOptions.target >= 3.5) {
-        // https://github.com/vuejs/core/pull/10801
-        if (scriptSetupRanges.props.define?.typeArg) {
-            yield `__typeProps: __VLS_typeProps,${common_1.newLine}`;
-        }
-        if (scriptSetupRanges.emits.define?.typeArg) {
-            yield `__typeEmits: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
+    else {
+        yield `__typeEmits: {} as __VLS_ModelEmitsType`;
+        const typeArg = scriptSetupRanges.emits.define?.typeArg;
+        if (typeArg) {
+            yield ` & `;
+            yield scriptSetup.content.slice(typeArg.start, typeArg.end);
         }
+        yield `,${common_1.newLine}`;
     }
 }
 //# sourceMappingURL=component.js.map

package/lib/codegen/script/globalTypes.js

@@ -15,15 +15,9 @@ declare global {
 	type __VLS_Element = ${vueCompilerOptions.target >= 3.3
         ? `import('${vueCompilerOptions.lib}/jsx-runtime').JSX.Element;`
         : `globalThis.JSX.Element;`}
-	type __VLS_GlobalComponents = import('${vueCompilerOptions.lib}').GlobalComponents
-		& Pick<typeof import('${vueCompilerOptions.lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;
-	type __VLS_BuiltInPublicProps = ${vueCompilerOptions.target >= 3.4
-        ? `import('${vueCompilerOptions.lib}').PublicProps;`
-        : vueCompilerOptions.target >= 3.0
-            ? `import('${vueCompilerOptions.lib}').VNodeProps
-					& import('${vueCompilerOptions.lib}').AllowedComponentProps
-					& import('${vueCompilerOptions.lib}').ComponentCustomProps;`
-            : `globalThis.JSX.IntrinsicAttributes;`}
+	type __VLS_GlobalComponents = ${vueCompilerOptions.target >= 3.5
+        ? `import('${vueCompilerOptions.lib}').GlobalComponents;`
+        : `import('${vueCompilerOptions.lib}').GlobalComponents & Pick<typeof import('${vueCompilerOptions.lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`}
 	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
 	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
 
@@ -63,6 +57,7 @@ declare global {
 		: T;
 	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;
 
 	type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? { [P in N]: C } : {};
 	type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =

package/lib/codegen/script/index.js

@@ -105,7 +105,17 @@ function* generateScript(options) {
         yield* generateDefineProp(options, options.sfc.scriptSetup);
         yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
     }
-    yield common_1.endOfLine;
+    yield `;`;
+    if (options.sfc.scriptSetup) {
+        // #4569
+        yield [
+            '',
+            'scriptSetup',
+            options.sfc.scriptSetup.content.length,
+            exports.codeFeatures.verification,
+        ];
+    }
+    yield common_1.newLine;
     if (options.globalTypes) {
         yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions);
     }

package/lib/codegen/script/scriptSetup.js

@@ -19,6 +19,15 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
     const definePropMirrors = new Map();
     if (scriptSetup.generic) {
         if (!options.scriptRanges?.exportDefault) {
+            if (options.sfc.scriptSetup) {
+                // #4569
+                yield [
+                    '',
+                    'scriptSetup',
+                    options.sfc.scriptSetup.content.length,
+                    index_1.codeFeatures.verification,
+                ];
+            }
             yield `export default `;
         }
         yield `(<`;
@@ -32,12 +41,12 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
             yield `,`;
         }
         yield `>(${common_1.newLine}`
-            + `	__VLS_props: Awaited<typeof __VLS_setup>['props'],${common_1.newLine}`
-            + `	__VLS_ctx?: ${ctx.helperTypes.Prettify.name}<Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__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_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 = ['typeof __VLS_modelEmitsType'];
+        const emitTypes = ['__VLS_ModelEmitsType'];
         if (scriptSetupRanges.emits.define) {
             emitTypes.unshift(`typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}`);
         }
@@ -231,15 +240,16 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
         yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end, index_1.codeFeatures.navigation);
         yield `,${common_1.newLine}`;
     }
-    if (scriptSetupRanges.emits.define || scriptSetupRanges.defineProp.some(p => p.isModel)) {
-        yield `	emits: ({} as __VLS_NormalizeEmits<typeof __VLS_modelEmitsType`;
-        if (scriptSetupRanges.emits.define) {
-            yield ` & typeof `;
-            yield scriptSetupRanges.emits.name ?? '__VLS_emit';
-        }
-        yield `>),${common_1.newLine}`;
-    }
+    yield* (0, component_1.generateEmitsOption)(options, scriptSetup, scriptSetupRanges);
     yield `})${common_1.endOfLine}`;
+    yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
+        ? `import('${options.vueCompilerOptions.lib}').PublicProps;`
+        : options.vueCompilerOptions.target >= 3.0
+            ? `import('${options.vueCompilerOptions.lib}').VNodeProps
+					& import('${options.vueCompilerOptions.lib}').AllowedComponentProps
+					& import('${options.vueCompilerOptions.lib}').ComponentCustomProps;`
+            : `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 common_1.endOfLine;
@@ -279,6 +289,8 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             if (defineProp.name && defineProp.nameIsString) {
                 // 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);
@@ -291,18 +303,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             yield defineProp.required
                 ? `: `
                 : `?: `;
-            if (defineProp.type) {
-                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
-            }
-            else if (!defineProp.nameIsString) {
-                yield `NonNullable<typeof ${propName}['value']>`;
-            }
-            else if (defineProp.defaultValue) {
-                yield `typeof __VLS_defaults['${propName}']`;
-            }
-            else {
-                yield `any`;
-            }
+            yield* generateDefinePropType(scriptSetup, propName, defineProp);
             yield `,${common_1.newLine}`;
             if (defineProp.modifierType) {
                 let propModifierName = 'modelModifiers';
@@ -329,9 +330,13 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
     yield common_1.endOfLine;
 }
 function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
-    yield `const __VLS_modelEmitsType = `;
+    yield `type __VLS_ModelEmitsType = `;
     if (scriptSetupRanges.defineProp.filter(p => p.isModel).length) {
-        yield `(await import('${options.vueCompilerOptions.lib}')).defineEmits<{${common_1.newLine}`;
+        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;
@@ -342,19 +347,34 @@ function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
                 propName = propName.replace(/['"]+/g, '');
             }
             yield `'update:${propName}': [${propName}:`;
-            if (defineProp.type) {
-                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
-            }
-            else {
-                yield `any`;
-            }
+            yield* generateDefinePropType(scriptSetup, propName, defineProp);
             yield `]${common_1.endOfLine}`;
         }
-        yield `}>()`;
+        yield `}`;
+        if (options.vueCompilerOptions.target < 3.5) {
+            yield `>()`;
+        }
     }
     else {
         yield `{}`;
     }
     yield common_1.endOfLine;
 }
+function* generateDefinePropType(scriptSetup, propName, defineProp) {
+    if (defineProp.type) {
+        // Infer from defineProp<T>
+        yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+    }
+    else if ((defineProp.name && defineProp.nameIsString) || !defineProp.nameIsString) {
+        // Infer from actual prop declaration code 
+        yield `NonNullable<typeof ${propName}['value']>`;
+    }
+    else if (defineProp.defaultValue) {
+        // Infer from defineProp({default: T})
+        yield `typeof __VLS_defaults['${propName}']`;
+    }
+    else {
+        yield `any`;
+    }
+}
 //# sourceMappingURL=scriptSetup.js.map

package/lib/codegen/template/element.js

@@ -16,6 +16,7 @@ const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
 const propertyAccess_1 = require("./propertyAccess");
 const templateChild_1 = require("./templateChild");
+const objectProperty_1 = require("./objectProperty");
 const colonReg = /:/g;
 function* generateComponent(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
@@ -168,6 +169,13 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     yield* generateVScope(options, ctx, node, props);
     ctx.usedComponentCtxVars.add(componentCtxVar);
     const usedComponentEventsVar = yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEmit, var_componentEvents);
+    if (var_defineComponentCtx && ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
+        yield `const ${componentCtxVar} = __VLS_nonNullable(__VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance}))${common_1.endOfLine}`;
+    }
+    if (usedComponentEventsVar) {
+        yield `let ${var_componentEmit}!: typeof ${componentCtxVar}.emit${common_1.endOfLine}`;
+        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${common_1.endOfLine}`;
+    }
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     if (slotDir) {
         yield* generateComponentSlot(options, ctx, node, slotDir, currentComponent, componentCtxVar);
@@ -175,13 +183,6 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     else {
         yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
     }
-    if (var_defineComponentCtx && ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
-        yield `const ${componentCtxVar} = __VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance})!${common_1.endOfLine}`;
-    }
-    if (usedComponentEventsVar) {
-        yield `let ${var_componentEmit}!: typeof ${componentCtxVar}.emit${common_1.endOfLine}`;
-        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${common_1.endOfLine}`;
-    }
 }
 function* generateElement(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
@@ -271,11 +272,23 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
         ctx.hasSlotElements.add(currentComponent);
     }
     const slotBlockVars = [];
-    let hasProps = false;
+    yield `const {`;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc);
+        yield ': __VLS_thisSlot';
+    }
+    else {
+        yield `default: `;
+        yield* (0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+            ? '#'.length
+            : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `__VLS_thisSlot`);
+    }
+    yield `} = __VLS_nonNullable(${componentCtxVar}.slots)${common_1.endOfLine}`;
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, common_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
         (0, common_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
-        hasProps = true;
         if (!slotDir.exp.content.includes(':')) {
             yield `const [`;
             yield [
@@ -284,7 +297,7 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
                 slotDir.exp.loc.start.offset,
                 ctx.codeFeatures.all,
             ];
-            yield `] = __VLS_getSlotParams(`;
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${common_1.endOfLine}`;
         }
         else {
             yield `const `;
@@ -294,23 +307,9 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
                 slotDir.exp.loc.start.offset,
                 ctx.codeFeatures.all,
             ];
-            yield ` = __VLS_getSlotParam(`;
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${common_1.endOfLine}`;
         }
     }
-    yield* (0, common_1.wrapWith)((slotDir.arg ?? slotDir).loc.start.offset, (slotDir.arg ?? slotDir).loc.end.offset, ctx.codeFeatures.verification, `(${componentCtxVar}.slots!)`, ...(slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content
-        ? (0, propertyAccess_1.generatePropertyAccess)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc)
-        : [
-            `.`,
-            ...(0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
-                ? '#'.length
-                : slotDir.loc.source.startsWith('v-slot:')
-                    ? 'v-slot:'.length
-                    : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`)
-        ]));
-    if (hasProps) {
-        yield `)`;
-    }
-    yield common_1.endOfLine;
     for (const varName of slotBlockVars) {
         ctx.addLocalVariable(varName);
     }
@@ -328,7 +327,7 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
         isStatic = slotDir.arg.isStatic;
     }
     if (isStatic && slotDir && !slotDir.arg) {
-        yield `${componentCtxVar}.slots!['`;
+        yield `__VLS_nonNullable(${componentCtxVar}.slots)['`;
         yield [
             '',
             'template',

package/lib/codegen/template/elementChildren.js

@@ -18,7 +18,7 @@ function* generateElementChildren(options, ctx, node, currentComponent, componen
         && node.children.length
         && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
         && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
-        yield `(${componentCtxVar}.slots!).`;
+        yield `__VLS_nonNullable(${componentCtxVar}.slots).`;
         yield* (0, common_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
         yield common_1.endOfLine;
     }

package/lib/codegen/template/elementEvents.js

@@ -144,7 +144,7 @@ function isCompoundExpression(ts, ast) {
                     if (ts.isArrowFunction(child_2)) {
                         result = false;
                     }
-                    else if (ts.isIdentifier(child_2)) {
+                    else if (isPropertyAccessOrId(ts, child_2)) {
                         result = false;
                     }
                 });
@@ -156,4 +156,13 @@ function isCompoundExpression(ts, ast) {
     }
     return result;
 }
+function isPropertyAccessOrId(ts, node) {
+    if (ts.isIdentifier(node)) {
+        return true;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return isPropertyAccessOrId(ts, node.expression);
+    }
+    return false;
+}
 //# sourceMappingURL=elementEvents.js.map

package/lib/codegen/template/elementProps.js

@@ -86,7 +86,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                         }
                         : false,
                 }, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize)
-                : [propName]), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+                : (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.verification, propName)), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
             if (!enableCodeFeatures) {
                 yield (0, muggle_string_1.toString)([...codes]);
             }

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

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

package/lib/codegen/template/objectKey.js

@@ -0,0 +1,34 @@
+"use strict";
+// import type { Code, VueCodeInformation } from '../../types';
+// import type { TemplateCodegenContext } from './context';
+// import type { TemplateCodegenOptions } from './index';
+// import { generateInterpolation } from './interpolation';
+// import { generateStringLiteralKey } from './stringLiteralKey';
+Object.defineProperty(exports, "__esModule", { value: true });
+// export function* generateObjectKey(
+// 	options: TemplateCodegenOptions,
+// 	ctx: TemplateCodegenContext,
+// 	code: string,
+// 	offset: number,
+// 	features: VueCodeInformation,
+// 	astHolder?: any
+// ): Generator<Code> {
+// 	yield `[`;
+// 	if (code.startsWith('[') && code.endsWith(']')) {
+// 		yield* generateInterpolation(
+// 			options,
+// 			ctx,
+// 			code.slice(1, -1),
+// 			astHolder,
+// 			offset + 1,
+// 			features,
+// 			'',
+// 			''
+// 		);
+// 	}
+// 	else {
+// 		yield* generateStringLiteralKey(code, offset, features)
+// 	}
+// 	yield `]`;
+// }
+//# sourceMappingURL=objectKey.js.map

package/lib/languageModule.js

@@ -1,14 +1,15 @@
 "use strict";
+/// <reference types="@volar/typescript" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
 const language_core_1 = require("@volar/language-core");
-const plugins_1 = require("./plugins");
-const vueFile_1 = require("./virtualFile/vueFile");
 const CompilerDOM = require("@vue/compiler-dom");
-const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const plugins_1 = require("./plugins");
 const file_html_1 = require("./plugins/file-html");
 const file_md_1 = require("./plugins/file-md");
 const file_vue_1 = require("./plugins/file-vue");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const vueFile_1 = require("./virtualFile/vueFile");
 const normalFileRegistries = [];
 const holderFileRegistries = [];
 function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {
@@ -73,11 +74,11 @@ function createVueLanguagePlugin(ts, asFileName, getProjectVersion, isRootFile,
         createVirtualCode(scriptId, languageId, snapshot) {
             if (languageId === 'vue' || languageId === 'markdown' || languageId === 'html') {
                 const fileName = asFileName(scriptId);
-                if (!pluginContext.globalTypesHolder && getProjectVersion() !== canonicalRootFileNamesVersion) {
+                if (getProjectVersion() !== canonicalRootFileNamesVersion) {
                     canonicalRootFileNamesVersion = getProjectVersion();
-                    if (isRootFile(fileName)) {
-                        pluginContext.globalTypesHolder = fileName;
-                    }
+                }
+                if (!pluginContext.globalTypesHolder && isRootFile(fileName)) {
+                    pluginContext.globalTypesHolder = fileName;
                 }
                 const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
                 const code = fileRegistry.get(fileName);

package/lib/languagePlugin.d.ts

@@ -0,0 +1,8 @@
+import { type LanguagePlugin } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { VueCompilerOptions } from './types';
+import { VueVirtualCode } from './virtualFile/vueFile';
+export declare function createRootFileChecker(getProjectVersion: (() => string) | undefined, getRootFileNames: () => string[], caseSensitive: boolean): (fileName: string) => boolean;
+export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, _getProjectVersion: (() => string) | undefined, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
+export declare function createVueLanguagePlugin2<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
+export declare function getAllExtensions(options: VueCompilerOptions): string[];