@vue/language-core 3.0.0-alpha.2 → 3.0.0-alpha.4

package/lib/codegen/globalTypes.js

@@ -13,7 +13,7 @@ function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEv
     ].map(v => (typeof v === 'boolean' ? Number(v) : v)).join('_') + '.d.ts';
 }
 function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
-    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
+    const fnPropsType = `(T extends { $props: infer Props } ? Props : {})${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
     let text = ``;
     if (target < 3.5) {
         text += `
@@ -51,10 +51,31 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		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] } :
 		${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 :
-		{};
+	type __VLS_FunctionalComponentCtx<T, K> = __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: infer Ctx } ? NonNullable<Ctx> : never : any
+		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+	>;
+	type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+		: T extends (props: infer P, ...args: any) => any ? P
+		: {};
+	type __VLS_FunctionalComponent<T> = (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
+		__ctx?: {
+			attrs?: any,
+			slots?: T extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : Record<string, any>,
+			emit?: T extends { $emit: infer Emit } ? Emit : {},
+			props?: ${fnPropsType},
+			expose?: (exposed: T) => void,
+		}
+	};
+	type __VLS_NormalizeSlotReturns<S, R = NonNullable<S> extends (...args: any) => infer K ? K : any> = R extends any[] ? {
+		[K in keyof R]: R[K] extends infer V
+			? V extends Element ? V
+			: V extends new (...args: any) => infer R ? ReturnType<__VLS_FunctionalComponent<R>>
+			: V extends (...args: any) => infer R ? R
+			: any
+			: never
+	} : R;
 	type __VLS_IsFunction<T, K> = K extends keyof T
 		? __VLS_IsAny<T[K]> extends false
 		? unknown extends T[K]
@@ -62,13 +83,13 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: true
 		: false
 		: false;
-	type __VLS_NormalizeComponentEvent<Props, Events, onEvent extends keyof Props, Event extends keyof Events, CamelizedEvent extends keyof Events> = (
+	type __VLS_NormalizeComponentEvent<Props, Emits, onEvent extends keyof Props, Event extends keyof Emits, CamelizedEvent extends keyof Emits> = (
 		__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] }
+			: __VLS_IsFunction<Emits, Event> extends true
+				? { [K in onEvent]?: Emits[Event] }
+				: __VLS_IsFunction<Emits, CamelizedEvent> extends true
+					? { [K in onEvent]?: Emits[CamelizedEvent] }
 					: Props
 	)${checkUnknownEvents ? '' : ' & Record<string, unknown>'};
 	// fix https://github.com/vuejs/language-tools/issues/926
@@ -94,11 +115,16 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 			}
 		>
 	>;
+	type __VLS_ResolveEmits<
+		Comp,
+		Emits,
+		TypeEmits = ${target >= 3.6 ? `Comp extends { __typeEmits?: infer T } ? unknown extends T ? {} : import('${lib}').ShortEmitsToObject<T> : {}` : `{}`},
+		NormalizedEmits = __VLS_NormalizeEmits<Emits> extends infer E ? string extends keyof E ? {} : E : never,
+	> = __VLS_SpreadMerge<NormalizedEmits, TypeEmits>;
+	type __VLS_ResolveDirectives<T> = {
+		[K in Exclude<keyof T, keyof __VLS_GlobalDirectives> & string as \`v\${Capitalize<K>}\`]: T[K];
+	};
 	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
-	type __VLS_PickFunctionalComponentCtx<T, K> = NonNullable<__VLS_PickNotAny<
-		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
-		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
-	>>;
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
@@ -123,19 +149,13 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 			: (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
 	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
 	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
-		T extends new (...args: any) => any
-		? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
-			__ctx?: {
-				attrs?: any;
-				slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : any;
-				emit?: K extends { $emit: infer Emit } ? Emit : any;
-				expose?(exposed: K): void;
-				props?: ${fnPropsType};
-			}
-		}
+		T extends new (...args: any) => any ? __VLS_FunctionalComponent<K>
 		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		${(target === 2.7
+        ? `: T extends import('vue').AsyncComponent ? (props: {}, ctx?: any) => any`
+        : ``)}
 		: T extends (...args: any) => any ? T
-		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
+		: __VLS_FunctionalComponent<{}>;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
 	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;

package/lib/codegen/script/src.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSrc = generateSrc;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
 function* generateSrc(src) {
     if (src === true) {
         return;
@@ -21,10 +22,10 @@ function* generateSrc(src) {
         text = text + '.js';
     }
     yield `export * from `;
-    yield* (0, utils_1.generateSfcBlockAttrValue)(src, text, {
+    yield* (0, wrapWith_1.wrapWith)(src.offset, src.offset + src.text.length, 'main', {
         ...codeFeatures_1.codeFeatures.all,
-        ...text === src.text ? codeFeatures_1.codeFeatures.navigation : codeFeatures_1.codeFeatures.navigationWithoutRename,
-    });
+        ...text !== src.text ? codeFeatures_1.codeFeatures.navigationWithoutRename : {},
+    }, `'`, [text.slice(0, src.text.length), 'main', src.offset, utils_1.combineLastMapping], text.slice(src.text.length), `'`);
     yield utils_1.endOfLine;
     yield `export { default } from '${text}'${utils_1.endOfLine}`;
 }

package/lib/codegen/script/template.js

@@ -51,7 +51,7 @@ function* generateTemplateElements() {
     yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
 }
 function* generateTemplateComponents(options) {
-    const types = [];
+    const types = [`typeof __VLS_ctx`];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
         const { componentsOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_componentsOption = `;
@@ -64,7 +64,6 @@ function* generateTemplateComponents(options) {
         yield utils_1.endOfLine;
         types.push(`typeof __VLS_componentsOption`);
     }
-    types.push(`typeof __VLS_ctx`);
     yield `type __VLS_LocalComponents =`;
     for (const type of types) {
         yield ` & `;
@@ -74,7 +73,7 @@ function* generateTemplateComponents(options) {
     yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
-    const types = [];
+    const types = [`typeof __VLS_ctx`];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
         const { directivesOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_directivesOption = `;
@@ -85,9 +84,8 @@ function* generateTemplateDirectives(options) {
             codeFeatures_1.codeFeatures.navigation,
         ];
         yield utils_1.endOfLine;
-        types.push(`typeof __VLS_directivesOption`);
+        types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
-    types.push(`typeof __VLS_ctx`);
     yield `type __VLS_LocalDirectives =`;
     for (const type of types) {
         yield ` & `;

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

@@ -161,6 +161,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[]>;
     currentComponent: {
         ctxVar: string;
+        childTypes: string[];
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];

package/lib/codegen/template/element.js

@@ -35,9 +35,11 @@ function* generateComponent(options, ctx, node) {
     const componentVNodeVar = ctx.getInternalVariable();
     const componentCtxVar = ctx.getInternalVariable();
     const isComponentTag = node.tag.toLowerCase() === 'component';
+    ctx.currentComponent?.childTypes.push(`typeof ${componentVNodeVar}`);
     ctx.currentComponent = {
         ctxVar: componentCtxVar,
-        used: false
+        childTypes: [],
+        used: false,
     };
     let props = node.props;
     let dynamicTagInfo;
@@ -159,7 +161,7 @@ function* generateComponent(options, ctx, node) {
     yield* (0, wrapWith_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `, ...__VLS_functionalComponentArgsRest(${componentFunctionalVar}))${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
-    yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentFunctionalVar, componentVNodeVar, componentCtxVar);
+    yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
     const [refName, offset] = yield* generateElementReference(options, ctx, node);
     const tag = (0, shared_2.hyphenateTag)(node.tag);
@@ -188,7 +190,7 @@ function* generateComponent(options, ctx, node) {
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
     if (ctx.currentComponent.used) {
-        yield `var ${componentCtxVar}!: __VLS_PickFunctionalComponentCtx<typeof ${componentOriginalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
+        yield `var ${componentCtxVar}!: __VLS_FunctionalComponentCtx<typeof ${componentOriginalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
     }
 }
 function* generateElement(options, ctx, node) {
@@ -197,6 +199,7 @@ function* generateElement(options, ctx, node) {
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
         : undefined;
     const failedPropExps = [];
+    ctx.currentComponent?.childTypes.push(`__VLS_NativeElements['${node.tag}']`);
     yield `__VLS_asFunctionalElement(__VLS_elements`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {
@@ -223,7 +226,10 @@ function* generateElement(options, ctx, node) {
         ctx.inheritedAttrVars.add(`__VLS_elements.${node.tag}`);
     }
     (0, styleScopedClasses_1.collectStyleScopedClassReferences)(options, ctx, node);
+    const { currentComponent } = ctx;
+    ctx.currentComponent = undefined;
     yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
+    ctx.currentComponent = currentComponent;
 }
 function* generateFailedPropExps(options, ctx, failedPropExps) {
     for (const failedExp of failedPropExps) {

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

@@ -3,7 +3,7 @@ import type * as ts from 'typescript';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentOriginalVar: string, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
 export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string): Generator<Code>;
 export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function generateModelEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;

package/lib/codegen/template/elementEvents.js

@@ -11,9 +11,9 @@ const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
 const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
-function* generateElementEvents(options, ctx, node, componentFunctionalVar, componentVNodeVar, componentCtxVar) {
-    let emitVar;
-    let eventsVar;
+const objectProperty_1 = require("./objectProperty");
+function* generateElementEvents(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar) {
+    let emitsVar;
     let propsVar;
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -23,12 +23,10 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
                     && prop.name === 'model'
                     && (!prop.arg || prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))) {
             ctx.currentComponent.used = true;
-            if (!emitVar) {
-                emitVar = ctx.getInternalVariable();
-                eventsVar = ctx.getInternalVariable();
+            if (!emitsVar) {
+                emitsVar = ctx.getInternalVariable();
                 propsVar = ctx.getInternalVariable();
-                yield `let ${emitVar}!: typeof ${componentCtxVar}.emit${utils_1.endOfLine}`;
-                yield `let ${eventsVar}!: __VLS_NormalizeEmits<typeof ${emitVar}>${utils_1.endOfLine}`;
+                yield `let ${emitsVar}!: __VLS_ResolveEmits<typeof ${componentOriginalVar}, typeof ${componentCtxVar}.emit>${utils_1.endOfLine}`;
                 yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentFunctionalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
             }
             let source = prop.arg?.loc.source ?? 'model-value';
@@ -45,7 +43,13 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
                 propPrefix = 'onVnode-';
                 emitPrefix = 'vnode-';
             }
-            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + source)}', '${emitPrefix + source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> => ({${utils_1.newLine}`;
+            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${(0, shared_1.camelize)(propPrefix + source)}', '${emitPrefix + source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> => (${utils_1.newLine}`;
+            if (prop.name === 'on') {
+                yield `{ `;
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, emitPrefix + source, start, ctx.codeFeatures.navigation, undefined, true);
+                yield `: {} as any } as typeof ${emitsVar},${utils_1.newLine}`;
+            }
+            yield `{ `;
             if (prop.name === 'on') {
                 yield* generateEventArg(ctx, source, start, propPrefix.slice(0, -1));
                 yield `: `;

package/lib/codegen/template/vSlot.js

@@ -28,7 +28,9 @@ function* generateVSlot(options, ctx, node, slotDir) {
             }
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children.at(-1).loc.end.offset, ctx.codeFeatures.navigation, `default`);
+            // #932: reference for implicit default slot
+            const { start, end } = getElementInnerLoc(options, node);
+            yield* (0, wrapWith_1.wrapWith)(start, end, ctx.codeFeatures.navigation, `default`);
         }
         yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
@@ -44,6 +46,12 @@ function* generateVSlot(options, ctx, node, slotDir) {
     for (const varName of slotBlockVars) {
         ctx.removeLocalVariable(varName);
     }
+    if (options.vueCompilerOptions.strictSlotChildren && node.children.length) {
+        const { start, end } = getElementInnerLoc(options, node);
+        yield `(): __VLS_NormalizeSlotReturns<typeof ${slotVar}> => (`;
+        yield* (0, wrapWith_1.wrapWith)(start, end, ctx.codeFeatures.verification, `{} as [`, ...ctx.currentComponent.childTypes.map(name => `${name}, `), `]`);
+        yield `)${utils_1.endOfLine}`;
+    }
     if (slotDir) {
         let isStatic = true;
         if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -112,4 +120,26 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
         ];
     }
 }
+function getElementInnerLoc(options, node) {
+    if (node.children.length) {
+        let start = node.children[0].loc.start.offset;
+        let end = node.children.at(-1).loc.end.offset;
+        while (options.template.content[start - 1] !== '>') {
+            start--;
+        }
+        while (options.template.content[end] !== '<') {
+            end++;
+        }
+        return {
+            start,
+            end,
+        };
+    }
+    else {
+        return {
+            start: node.loc.start.offset,
+            end: node.loc.end.offset,
+        };
+    }
+}
 //# sourceMappingURL=vSlot.js.map

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

@@ -1,6 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code, SfcBlock, SfcBlockAttr, VueCodeInformation } from '../../types';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
@@ -18,4 +18,3 @@ export declare function collectIdentifiers(ts: typeof import('typescript'), node
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
-export declare function generateSfcBlockAttrValue(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -6,7 +6,6 @@ exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-exports.generateSfcBlockAttrValue = generateSfcBlockAttrValue;
 const shared_1 = require("../../utils/shared");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
@@ -65,19 +64,4 @@ function generateSfcBlockSection(block, start, end, features) {
         features,
     ];
 }
-function* generateSfcBlockAttrValue(src, text, features) {
-    const { offset, quotes } = src;
-    if (!quotes) {
-        yield [``, 'main', offset, { verification: true }];
-    }
-    yield [
-        `'${text}'`,
-        'main',
-        quotes ? offset - 1 : offset,
-        features
-    ];
-    if (!quotes) {
-        yield [``, 'main', offset + text.length, { __combineOffset: 2 }];
-    }
-}
 //# sourceMappingURL=index.js.map

package/lib/plugins/vue-template-inline-css.js

@@ -21,7 +21,7 @@ const plugin = () => {
             if (embeddedFile.id !== 'template_inline_css' || !sfc.template?.ast) {
                 return;
             }
-            embeddedFile.parentCodeId = 'template';
+            embeddedFile.parentCodeId = sfc.template.lang === 'md' ? 'root_tags' : 'template';
             embeddedFile.content.push(...generate(sfc.template.ast));
         },
     };

package/lib/plugins/vue-template-inline-ts.js

@@ -38,13 +38,13 @@ const plugin = ctx => {
         },
         resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
             // access template content to watch change
-            (() => sfc.template?.content)();
+            void sfc.template?.content;
             const parsed = parseds.get(sfc);
             if (parsed) {
                 const codes = parsed.get(embeddedFile.id);
                 if (codes) {
                     embeddedFile.content.push(...codes);
-                    embeddedFile.parentCodeId = 'template';
+                    embeddedFile.parentCodeId = sfc.template?.lang === 'md' ? 'root_tags' : 'template';
                 }
             }
         },

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

@@ -198,6 +198,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[]>;
         currentComponent: {
             ctxVar: string;
+            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];

package/lib/types.d.ts

@@ -23,6 +23,7 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
+    strictSlotChildren: boolean;
     strictVModel: boolean;
     checkUnknownProps: boolean;
     checkUnknownEvents: boolean;

package/lib/utils/ts.js

@@ -217,6 +217,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
+        strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
         checkUnknownProps: strictTemplates,
         checkUnknownEvents: strictTemplates,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.0-alpha.2",
+	"version": "3.0.0-alpha.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "79247b7c24b7202ec676723440fdb36c38e6d450"
+	"gitHead": "1769cd6b94ec9e0cc2681b8dbba904f35856ba1c"
 }

package/lib/codegen/utils/objectProperty.d.ts

@@ -1,3 +0,0 @@
-import type { Code, VueCodeInformation } from '../../types';
-export declare function getObjectProperty(code: string): string;
-export declare function generateObjectProperty(code: string, source: string, offset: number, features: VueCodeInformation, hasQuotes?: boolean, shouldCamelize?: boolean): Generator<Code>;

package/lib/codegen/utils/objectProperty.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectProperty = getObjectProperty;
-exports.generateObjectProperty = generateObjectProperty;
-const shared_1 = require("@vue/shared");
-const utils_1 = require("../utils");
-const camelized_1 = require("../utils/camelized");
-const stringLiteralKey_1 = require("../utils/stringLiteralKey");
-function getObjectProperty(code) {
-    if (utils_1.identifierRegex.test(code)) {
-        return code;
-    }
-    else {
-        return `'${code}'`;
-    }
-}
-function* generateObjectProperty(code, source, offset, features, hasQuotes = false, shouldCamelize = false) {
-    const start = offset;
-    const end = offset + code.length;
-    if (hasQuotes) {
-        code = code.slice(1, -1);
-        offset++;
-    }
-    if (shouldCamelize) {
-        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
-            yield* (0, camelized_1.generateCamelized)(code, source, offset, features);
-        }
-        else {
-            yield* (0, utils_1.wrapWith)(start, end, source, features, `'`, ...(0, camelized_1.generateCamelized)(code, source, offset, features), `'`);
-        }
-    }
-    else {
-        if (utils_1.identifierRegex.test(code)) {
-            yield [code, source, offset, features];
-        }
-        else {
-            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, source, offset, features);
-        }
-    }
-}
-//# sourceMappingURL=objectProperty.js.map