@vue/language-core 3.0.2 → 3.0.4

package/index.d.ts

@@ -1,10 +1,10 @@
 export * from './lib/codegen/globalTypes';
 export * from './lib/codegen/template';
-export * from './lib/codegen/utils';
 export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
 export * from './lib/types';
+export * from './lib/utils/collectBindings';
 export * from './lib/utils/parseSfc';
 export * from './lib/utils/shared';
 export * from './lib/utils/ts';

package/index.js

@@ -17,11 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 __exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
-__exportStar(require("./lib/codegen/utils"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
 __exportStar(require("./lib/types"), exports);
+__exportStar(require("./lib/utils/collectBindings"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
 __exportStar(require("./lib/utils/shared"), exports);
 __exportStar(require("./lib/utils/ts"), exports);

package/lib/codegen/codeFeatures.d.ts

@@ -87,6 +87,21 @@ declare const raw: {
         navigation: true;
         completion: true;
     };
+    doNotReportTs2339AndTs2551: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
+    doNotReportTs2353AndTs2561: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
+    doNotReportTs6133: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
 };
 export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
 export {};

package/lib/codegen/codeFeatures.js

@@ -73,6 +73,26 @@ const raw = {
         navigation: true,
         completion: true,
     },
+    doNotReportTs2339AndTs2551: {
+        verification: {
+            // https://typescript.tv/errors/#ts2339
+            // https://typescript.tv/errors/#ts2551
+            shouldReport: (_source, code) => String(code) !== '2339' && String(code) !== '2551',
+        },
+    },
+    doNotReportTs2353AndTs2561: {
+        verification: {
+            // https://typescript.tv/errors/#ts2353
+            // https://typescript.tv/errors/#ts2561
+            shouldReport: (_source, code) => String(code) !== '2353' && String(code) !== '2561',
+        },
+    },
+    doNotReportTs6133: {
+        verification: {
+            // https://typescript.tv/errors/#ts6133
+            shouldReport: (_source, code) => String(code) !== '6133',
+        },
+    },
 };
 exports.codeFeatures = raw;
 //# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/globalTypes.d.ts

@@ -1,3 +1,3 @@
 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;
+export declare function getGlobalTypesFileName(options: VueCompilerOptions): string;
+export declare function generateGlobalTypes(options: VueCompilerOptions): string;

package/lib/codegen/globalTypes.js

@@ -3,16 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalTypesFileName = getGlobalTypesFileName;
 exports.generateGlobalTypes = generateGlobalTypes;
 const shared_1 = require("../utils/shared");
-function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+function getGlobalTypesFileName(options) {
     return [
-        lib,
-        target,
-        checkUnknownProps,
-        checkUnknownEvents,
-        checkUnknownComponents,
+        options.lib,
+        options.target,
+        options.checkUnknownProps,
     ].map(v => (typeof v === 'boolean' ? Number(v) : v)).join('_') + '.d.ts';
 }
-function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+function generateGlobalTypes(options) {
+    const { lib, target, checkUnknownProps } = options;
     const fnPropsType = `(T extends { $props: infer Props } ? Props : {})${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
     let text = `// @ts-nocheck\nexport {};\n`;
     if (target < 3.5) {
@@ -50,7 +49,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		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] } :
-		${checkUnknownComponents ? '{}' : '{ [K in N0]: unknown }'};
+		{};
 	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
@@ -61,21 +60,13 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: {};
 	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,
-		}
+			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]
@@ -83,15 +74,19 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: true
 		: false
 		: false;
-	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<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>'};
+	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<Emits, Event> extends true
+			? { [K in onEvent]?: Emits[Event] }
+			: __VLS_IsFunction<Emits, CamelizedEvent> extends true
+				? { [K in onEvent]?: Emits[CamelizedEvent] }
+				: Props;
 	// 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
@@ -158,7 +153,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: T extends (...args: any) => any ? T
 		: __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_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T${checkUnknownProps ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
 	function __VLS_tryAsConstant<const T>(t: T): T;
 }

package/lib/codegen/script/component.js

@@ -6,6 +6,7 @@ exports.generateEmitsOption = generateEmitsOption;
 exports.generatePropsOption = generatePropsOption;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
+const merge_1 = require("../utils/merge");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     if (options.sfc.script && options.scriptRanges?.exportDefault
         && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
@@ -17,14 +18,21 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
         yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
     }
     yield `setup() {${utils_1.newLine}`;
-    yield `return {${utils_1.newLine}`;
+    const returns = [];
     if (ctx.bypassDefineComponent) {
+        yield* `const __VLS_returns = {${utils_1.newLine}`;
         yield* generateComponentSetupReturns(scriptSetupRanges);
+        yield `}${utils_1.endOfLine}`;
+        returns.push(`typeof __VLS_returns`);
     }
     if (scriptSetupRanges.defineExpose) {
-        yield `...__VLS_exposed,${utils_1.newLine}`;
+        returns.push(`typeof __VLS_exposed`);
+    }
+    if (returns.length) {
+        yield `return {} as `;
+        yield* (0, merge_1.generateIntersectMerge)(returns);
+        yield utils_1.endOfLine;
     }
-    yield `}${utils_1.endOfLine}`;
     yield `},${utils_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
         const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
@@ -77,10 +85,14 @@ function* generateEmitsOption(options, scriptSetupRanges) {
         }
     }
     if (options.vueCompilerOptions.target >= 3.5 && typeOptionCodes.length) {
-        yield* generateIntersectMerge('__typeEmits', typeOptionCodes);
+        yield `__typeEmits: {} as `;
+        yield* (0, merge_1.generateIntersectMerge)(typeOptionCodes);
+        yield `,${utils_1.newLine}`;
     }
     else if (optionCodes.length) {
-        yield* generateSpreadMerge('emits', optionCodes);
+        yield `emits: `;
+        yield* (0, merge_1.generateSpreadMerge)(optionCodes);
+        yield `,${utils_1.newLine}`;
     }
 }
 function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
@@ -121,35 +133,14 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
             && scriptSetupRanges.withDefaults?.arg) {
             yield `__defaults: __VLS_withDefaultsArg,${utils_1.newLine}`;
         }
-        yield* generateSpreadMerge('__typeProps', typeOptionCodes);
+        yield `__typeProps: `;
+        yield* (0, merge_1.generateSpreadMerge)(typeOptionCodes);
+        yield `,${utils_1.newLine}`;
     }
     if (useOption) {
-        yield* generateSpreadMerge('props', getOptionCodes.map(fn => fn()));
-    }
-}
-function* generateIntersectMerge(key, codes) {
-    yield `${key}: {} as `;
-    yield codes[0];
-    for (let i = 1; i < codes.length; i++) {
-        yield ` & `;
-        yield codes[i];
-    }
-    yield `,${utils_1.newLine}`;
-}
-function* generateSpreadMerge(key, codes) {
-    yield `${key}: `;
-    if (codes.length === 1) {
-        yield codes[0];
-    }
-    else {
-        yield `{${utils_1.newLine}`;
-        for (const code of codes) {
-            yield `...`;
-            yield code;
-            yield `,${utils_1.newLine}`;
-        }
-        yield `}`;
+        yield `props: `;
+        yield* (0, merge_1.generateSpreadMerge)(getOptionCodes.map(fn => fn()));
+        yield `,${utils_1.newLine}`;
     }
-    yield `,${utils_1.newLine}`;
 }
 //# sourceMappingURL=component.js.map

package/lib/codegen/script/index.js

@@ -12,24 +12,7 @@ const src_1 = require("./src");
 const template_1 = require("./template");
 function* generateScript(options) {
     const ctx = (0, context_1.createScriptCodegenContext)(options);
-    if (options.vueCompilerOptions.globalTypesPath) {
-        const globalTypesPath = options.vueCompilerOptions.globalTypesPath;
-        if (path.isAbsolute(globalTypesPath)) {
-            let relativePath = path.relative(path.dirname(options.fileName), globalTypesPath);
-            if (relativePath !== globalTypesPath
-                && !relativePath.startsWith('./')
-                && !relativePath.startsWith('../')) {
-                relativePath = './' + relativePath;
-            }
-            yield `/// <reference types="${relativePath}" />${utils_1.newLine}`;
-        }
-        else {
-            yield `/// <reference types="${globalTypesPath}" />${utils_1.newLine}`;
-        }
-    }
-    else {
-        yield `/* placeholder */${utils_1.newLine}`;
-    }
+    yield* generateGlobalTypesPath(options);
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script.src);
     }
@@ -112,6 +95,24 @@ function* generateScript(options) {
     }
     return ctx;
 }
+function* generateGlobalTypesPath(options) {
+    const globalTypesPath = options.vueCompilerOptions.globalTypesPath(options.fileName);
+    if (!globalTypesPath) {
+        yield `/* placeholder */${utils_1.newLine}`;
+    }
+    else if (path.isAbsolute(globalTypesPath)) {
+        let relativePath = path.relative(path.dirname(options.fileName), globalTypesPath);
+        if (relativePath !== globalTypesPath
+            && !relativePath.startsWith('./')
+            && !relativePath.startsWith('../')) {
+            relativePath = './' + relativePath;
+        }
+        yield `/// <reference types="${relativePath}" />${utils_1.newLine}`;
+    }
+    else {
+        yield `/// <reference types="${globalTypesPath}" />${utils_1.newLine}`;
+    }
+}
 function* generateScriptSectionPartiallyEnding(source, end, mark, delimiter = 'debugger') {
     yield delimiter;
     yield ['', source, end, codeFeatures_1.codeFeatures.verification];

package/lib/codegen/script/scriptSetup.js

@@ -248,10 +248,9 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
     yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
     if (syntax) {
-        if (!options.vueCompilerOptions.skipTemplateCodegen
-            && (scriptSetupRanges.defineSlots
-                || options.templateCodegen?.slots.length
-                || options.templateCodegen?.dynamicSlots.length)) {
+        if (scriptSetupRanges.defineSlots
+            || options.templateCodegen?.slots.length
+            || options.templateCodegen?.dynamicSlots.length) {
             yield `const __VLS_component = `;
             yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
             yield utils_1.endOfLine;

package/lib/codegen/script/template.js

@@ -11,6 +11,7 @@ const context_1 = require("../template/context");
 const interpolation_1 = require("../template/interpolation");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const utils_1 = require("../utils");
+const merge_1 = require("../utils/merge");
 function* generateTemplate(options, ctx) {
     ctx.generatedTemplate = true;
     const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
@@ -33,19 +34,8 @@ function* generateTemplateCtx(options) {
         exps.push(`{} as __VLS_StyleModules`);
     }
     yield `const __VLS_ctx = `;
-    if (exps.length === 1) {
-        yield exps[0];
-        yield `${utils_1.endOfLine}`;
-    }
-    else {
-        yield `{${utils_1.newLine}`;
-        for (const exp of exps) {
-            yield `...`;
-            yield exp;
-            yield `,${utils_1.newLine}`;
-        }
-        yield `}${utils_1.endOfLine}`;
-    }
+    yield* (0, merge_1.generateSpreadMerge)(exps);
+    yield utils_1.endOfLine;
 }
 function* generateTemplateElements() {
     yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
@@ -65,10 +55,7 @@ function* generateTemplateComponents(options) {
         types.push(`typeof __VLS_componentsOption`);
     }
     yield `type __VLS_LocalComponents =`;
-    for (const type of types) {
-        yield ` & `;
-        yield type;
-    }
+    yield* (0, merge_1.generateIntersectMerge)(types);
     yield utils_1.endOfLine;
     yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
@@ -87,10 +74,7 @@ function* generateTemplateDirectives(options) {
         types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
     yield `type __VLS_LocalDirectives =`;
-    for (const type of types) {
-        yield ` & `;
-        yield type;
-    }
+    yield* (0, merge_1.generateIntersectMerge)(types);
     yield utils_1.endOfLine;
     yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }

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

@@ -130,6 +130,9 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
         withoutSemantic: VueCodeInformation;
+        doNotReportTs2339AndTs2551: VueCodeInformation;
+        doNotReportTs2353AndTs2561: VueCodeInformation;
+        doNotReportTs6133: VueCodeInformation;
     };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
     inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
@@ -163,7 +166,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[]>;
     currentComponent: {
         ctxVar: string;
-        childTypes: string[];
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];

package/lib/codegen/template/element.js

@@ -35,10 +35,8 @@ 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,
-        childTypes: [],
         used: false,
     };
     let props = node.props;
@@ -112,7 +110,12 @@ function* generateComponent(options, ctx, node) {
             .map(name => `'${name}'`)
             .join(`, `);
         yield `>).`;
-        yield* generateCanonicalComponentName(node.tag, tagOffsets[0], ctx.codeFeatures.withoutHighlightAndCompletionAndNavigation);
+        yield* generateCanonicalComponentName(node.tag, tagOffsets[0], ctx.resolveCodeFeatures({
+            ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
+            ...options.vueCompilerOptions.checkUnknownComponents
+                ? codeFeatures_1.codeFeatures.verification
+                : codeFeatures_1.codeFeatures.doNotReportTs2339AndTs2551,
+        }));
         yield `${utils_1.endOfLine}`;
         const camelizedTag = (0, shared_1.camelize)(node.tag);
         if (utils_1.identifierRegex.test(camelizedTag)) {
@@ -142,14 +145,7 @@ function* generateComponent(options, ctx, node) {
     yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, false);
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
-    yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.resolveCodeFeatures({
-        verification: {
-            shouldReport(_source, code) {
-                // https://typescript.tv/errors/#ts6133
-                return String(code) !== '6133';
-            },
-        },
-    }), componentVNodeVar);
+    yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.doNotReportTs6133, componentVNodeVar);
     yield ` = ${componentFunctionalVar}`;
     yield* generateComponentGeneric(ctx);
     yield `(`;
@@ -196,7 +192,6 @@ 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) {

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

@@ -4,7 +4,7 @@ import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 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, features?: VueCodeInformation): Generator<Code>;
+export declare function generateEventArg(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, name: string, start: number, directive?: string, features?: VueCodeInformation): 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>;
 export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

package/lib/codegen/template/elementEvents.js

@@ -7,6 +7,7 @@ exports.generateModelEventExpression = generateModelEventExpression;
 exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -48,12 +49,12 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, compon
             yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> = (${utils_1.newLine}`;
             if (prop.name === 'on') {
                 yield `{ `;
-                yield* generateEventArg(ctx, source, start, emitPrefix.slice(0, -1), ctx.codeFeatures.navigation);
+                yield* generateEventArg(options, ctx, source, start, emitPrefix.slice(0, -1), ctx.codeFeatures.navigation);
                 yield `: {} as any } as typeof ${emitsVar},${utils_1.newLine}`;
             }
             yield `{ `;
             if (prop.name === 'on') {
-                yield* generateEventArg(ctx, source, start, propPrefix.slice(0, -1));
+                yield* generateEventArg(options, ctx, source, start, propPrefix.slice(0, -1));
                 yield `: `;
                 yield* generateEventExpression(options, ctx, prop);
             }
@@ -65,10 +66,14 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, compon
         }
     }
 }
-function* generateEventArg(ctx, name, start, directive = 'on', features = {
-    ...ctx.codeFeatures.withoutHighlightAndCompletion,
-    ...ctx.codeFeatures.navigationWithoutRename,
-}) {
+function* generateEventArg(options, ctx, name, start, directive = 'on', features) {
+    features ??= ctx.resolveCodeFeatures({
+        ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
+        ...codeFeatures_1.codeFeatures.navigationWithoutRename,
+        ...options.vueCompilerOptions.checkUnknownEvents
+            ? codeFeatures_1.codeFeatures.verification
+            : codeFeatures_1.codeFeatures.doNotReportTs2353AndTs2561,
+    });
     if (directive.length) {
         name = (0, shared_1.capitalize)(name);
     }

package/lib/codegen/template/elementProps.js

@@ -27,7 +27,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 && !prop.arg.loc.source.endsWith(']')) {
                 if (!isComponent) {
                     yield `...{ `;
-                    yield* (0, elementEvents_1.generateEventArg)(ctx, prop.arg.loc.source, prop.arg.loc.start.offset);
+                    yield* (0, elementEvents_1.generateEventArg)(options, ctx, prop.arg.loc.source, prop.arg.loc.start.offset);
                     yield `: `;
                     yield* (0, elementEvents_1.generateEventExpression)(options, ctx, prop);
                     yield `},`;
@@ -223,16 +223,9 @@ function getShouldCamelize(options, prop, propName) {
 function getPropsCodeInfo(ctx, strictPropsCheck) {
     return ctx.resolveCodeFeatures({
         ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
-        verification: strictPropsCheck || {
-            shouldReport(_source, code) {
-                // https://typescript.tv/errors/#ts2353
-                // https://typescript.tv/errors/#ts2561
-                if (String(code) === '2353' || String(code) === '2561') {
-                    return false;
-                }
-                return true;
-            },
-        },
+        ...strictPropsCheck
+            ? codeFeatures_1.codeFeatures.verification
+            : codeFeatures_1.codeFeatures.doNotReportTs2353AndTs2561,
     });
 }
 function getModelPropName(node, vueCompilerOptions) {

package/lib/codegen/template/interpolation.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInterpolation = generateInterpolation;
 const shared_1 = require("@vue/shared");
+const collectBindings_1 = require("../../utils/collectBindings");
 const shared_2 = require("../../utils/shared");
 const utils_1 = require("../utils");
 // https://github.com/vuejs/core/blob/fb0c3ca519f1fccf52049cd6b8db3a67a669afe9/packages/compiler-core/src/transforms/transformExpression.ts#L47
@@ -133,7 +134,7 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
         walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars);
     }
     else if (ts.isVariableDeclaration(node)) {
-        const bindingNames = (0, utils_1.collectBindingNames)(ts, node.name, ast);
+        const bindingNames = (0, collectBindings_1.collectBindingNames)(ts, node.name, ast);
         for (const name of bindingNames) {
             ctx.addLocalVariable(name);
             blockVars.push(name);
@@ -195,7 +196,7 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
 function walkIdentifiersInFunction(ts, node, ast, cb, ctx) {
     const functionArgs = [];
     for (const param of node.parameters) {
-        functionArgs.push(...(0, utils_1.collectBindingNames)(ts, param.name, ast));
+        functionArgs.push(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
         if (param.type) {
             walkIdentifiersInTypeNode(ts, param.type, cb);
         }

package/lib/codegen/template/vFor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVFor = generateVFor;
 exports.parseVForNode = parseVForNode;
 const CompilerDOM = require("@vue/compiler-dom");
+const collectBindings_1 = require("../../utils/collectBindings");
 const utils_1 = require("../utils");
 const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
@@ -13,7 +14,7 @@ function* generateVFor(options, ctx, node) {
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
         const collectAst = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, `const [${leftExpressionText}]`);
-        forBlockVars.push(...(0, utils_1.collectBindingNames)(options.ts, collectAst, collectAst));
+        forBlockVars.push(...(0, collectBindings_1.collectBindingNames)(options.ts, collectAst, collectAst));
         yield [
             leftExpressionText,
             'template',

package/lib/codegen/template/vSlot.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVSlot = generateVSlot;
 const CompilerDOM = require("@vue/compiler-dom");
+const collectBindings_1 = require("../../utils/collectBindings");
 const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -35,7 +36,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
     }
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, `(${slotDir.exp.content}) => {}`);
-        slotBlockVars.push(...(0, utils_1.collectBindingNames)(options.ts, slotAst, slotAst));
+        slotBlockVars.push(...(0, collectBindings_1.collectBindingNames)(options.ts, slotAst, slotAst));
         yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
     }
     for (const varName of slotBlockVars) {
@@ -45,11 +46,6 @@ function* generateVSlot(options, ctx, node, slotDir) {
     for (const varName of slotBlockVars) {
         ctx.removeLocalVariable(varName);
     }
-    if (options.vueCompilerOptions.strictSlotChildren && node.children.length) {
-        yield `(): __VLS_NormalizeSlotReturns<typeof ${slotVar}> => (`;
-        yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, 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) {

package/lib/codegen/tenp.d.ts

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

package/lib/codegen/tenp.js

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

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

@@ -5,16 +5,6 @@ export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const identifierRegex: RegExp;
-export declare function collectBindingNames(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string[];
-export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
-    id: ts.Identifier;
-    isRest: boolean;
-    initializer: ts.Expression | undefined;
-}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
-    id: ts.Identifier;
-    isRest: boolean;
-    initializer: ts.Expression | undefined;
-}[];
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), inlineTsAsts: Map<string, ts.SourceFile> | undefined, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

package/lib/codegen/utils/index.js

@@ -1,40 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.collectBindingNames = collectBindingNames;
-exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-const shared_1 = require("../../utils/shared");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
 exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function collectBindingNames(ts, node, ast) {
-    return collectIdentifiers(ts, node).map(({ id }) => (0, shared_1.getNodeText)(ts, id, ast));
-}
-function collectIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
-    if (ts.isIdentifier(node)) {
-        results.push({ id: node, isRest, initializer });
-    }
-    else if (ts.isObjectBindingPattern(node)) {
-        for (const el of node.elements) {
-            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
-        }
-    }
-    else if (ts.isArrayBindingPattern(node)) {
-        for (const el of node.elements) {
-            if (ts.isBindingElement(el)) {
-                collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
-            }
-        }
-    }
-    else {
-        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, false));
-    }
-    return results;
-}
 function normalizeAttributeValue(node) {
     let offset = node.loc.start.offset;
     let content = node.loc.source;

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

@@ -0,0 +1,3 @@
+import type { Code } from '../../types';
+export declare function generateIntersectMerge(codes: Code[]): Generator<Code>;
+export declare function generateSpreadMerge(codes: Code[]): Generator<Code>;

package/lib/codegen/utils/merge.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIntersectMerge = generateIntersectMerge;
+exports.generateSpreadMerge = generateSpreadMerge;
+const index_1 = require("./index");
+function* generateIntersectMerge(codes) {
+    yield codes[0];
+    for (let i = 1; i < codes.length; i++) {
+        yield ` & `;
+        yield codes[i];
+    }
+}
+function* generateSpreadMerge(codes) {
+    if (codes.length === 1) {
+        yield codes[0];
+    }
+    else {
+        yield `{${index_1.newLine}`;
+        for (const code of codes) {
+            yield `...`;
+            yield code;
+            yield `,${index_1.newLine}`;
+        }
+        yield `}`;
+    }
+}
+//# sourceMappingURL=merge.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -72,5 +72,4 @@ export declare function parseBindingRanges(ts: typeof import('typescript'), ast:
     isDefaultImport?: boolean;
     isNamespace?: boolean;
 }[];
-export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, ast: ts.SourceFile): TextRange[];
 export {};

package/lib/parsers/scriptSetupRanges.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
 exports.parseBindingRanges = parseBindingRanges;
-exports.findBindingVars = findBindingVars;
-const utils_1 = require("../codegen/utils");
+const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
@@ -147,7 +146,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
-                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name);
+                    const identifiers = (0, collectBindings_1.collectBindingIdentifiers)(ts, parent.name);
                     for (const { id, isRest, initializer } of identifiers) {
                         const name = _getNodeText(id);
                         if (isRest) {
@@ -267,8 +266,8 @@ function parseBindingRanges(ts, ast) {
     ts.forEachChild(ast, node => {
         if (ts.isVariableStatement(node)) {
             for (const decl of node.declarationList.declarations) {
-                const vars = _findBindingVars(decl.name);
-                bindings.push(...vars.map(range => ({ range })));
+                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
+                bindings.push(...ranges.map(range => ({ range })));
             }
         }
         else if (ts.isFunctionDeclaration(node)) {
@@ -332,41 +331,6 @@ function parseBindingRanges(ts, ast) {
     function _getNodeText(node) {
         return (0, shared_1.getNodeText)(ts, node, ast);
     }
-    function _findBindingVars(left) {
-        return findBindingVars(ts, left, ast);
-    }
-}
-function findBindingVars(ts, left, ast) {
-    const vars = [];
-    worker(left);
-    return vars;
-    function worker(node) {
-        if (ts.isIdentifier(node)) {
-            vars.push((0, shared_1.getStartEnd)(ts, node, ast));
-        }
-        // { ? } = ...
-        // [ ? ] = ...
-        else if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
-            for (const property of node.elements) {
-                if (ts.isBindingElement(property)) {
-                    worker(property.name);
-                }
-            }
-        }
-        // { foo: ? } = ...
-        else if (ts.isPropertyAssignment(node)) {
-            worker(node.initializer);
-        }
-        // { foo } = ...
-        else if (ts.isShorthandPropertyAssignment(node)) {
-            vars.push((0, shared_1.getStartEnd)(ts, node.name, ast));
-        }
-        // { ...? } = ...
-        // [ ...? ] = ...
-        else if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node)) {
-            worker(node.expression);
-        }
-    }
 }
 function getStatementRange(ts, parents, node, ast) {
     let statementRange;

package/lib/plugins/file-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-css.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = ({ vueCompilerOptions }) => {
+    return {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter(block => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content = hitBlock.content.slice(0, change.start - hitBlock.loc.start.offset)
+                + change.newText
+                + hitBlock.content.slice(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = endTagRegex.test(oldContent) !== endTagRegex.test(newContent);
+            if (insertedEndTag) {
+                return;
+            }
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-css.js.map

package/lib/plugins/vue-root-tags.js

@@ -15,23 +15,16 @@ const plugin = () => {
             if (embeddedFile.id === 'root_tags') {
                 embeddedFile.content.push([sfc.content, undefined, 0, shared_1.allCodeFeatures]);
                 for (const block of [
+                    sfc.template,
                     sfc.script,
                     sfc.scriptSetup,
-                    sfc.template,
                     ...sfc.styles,
                     ...sfc.customBlocks,
                 ]) {
                     if (!block) {
                         continue;
                     }
-                    let content = block.content;
-                    if (content.endsWith('\r\n')) {
-                        content = content.slice(0, -2);
-                    }
-                    else if (content.endsWith('\n')) {
-                        content = content.slice(0, -1);
-                    }
-                    const offset = content.lastIndexOf('\n') + 1;
+                    const offset = block.content.lastIndexOf('\n', block.content.lastIndexOf('\n') - 1) + 1;
                     // fix folding range end position failed to mapping
                     (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.slice(block.startTagEnd, block.startTagEnd + offset), [
                         '',

package/lib/plugins/vue-style-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-style-css.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = () => {
+    return {
+        version: 2.1,
+        compileSFCStyle(_lang, style) {
+            return {
+                imports: [...parseCssImports(style)],
+                bindings: [...parseCssBindings(style)],
+                classNames: [...parseCssClassNames(style)],
+            };
+        },
+    };
+};
+exports.default = plugin;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+const cssBindingReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([a-z_]\w*))\s*\)/gi;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith("'") || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+function* parseCssBindings(css) {
+    css = fillBlank(css, commentReg);
+    const matchs = css.matchAll(cssBindingReg);
+    for (const match of matchs) {
+        const matchText = match.slice(1).find(t => t);
+        if (matchText) {
+            const offset = match.index + css.slice(match.index).indexOf(matchText);
+            yield { offset, text: matchText };
+        }
+    }
+}
+function* parseCssClassNames(css) {
+    css = fillBlank(css, commentReg, fragmentReg);
+    const matches = css.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        const matchText = match[1];
+        if (matchText) {
+            yield { offset: match.index, text: matchText };
+        }
+    }
+}
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=vue-style-css.js.map

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

@@ -1,5 +1,6 @@
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
+    getLang: () => string;
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
@@ -115,7 +116,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             name?: string;
         })[];
     } | undefined;
-    getLang: () => string;
+    getSetupSlotsAssignName: () => string | undefined;
     getGeneratedScript: () => {
         codes: Code[];
         generatedTemplate: boolean;
@@ -166,6 +167,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
             withoutSemantic: import("../types").VueCodeInformation;
+            doNotReportTs2339AndTs2551: import("../types").VueCodeInformation;
+            doNotReportTs2353AndTs2561: import("../types").VueCodeInformation;
+            doNotReportTs6133: import("../types").VueCodeInformation;
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
         inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
@@ -199,7 +203,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[]>;
         currentComponent: {
             ctxVar: string;
-            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];

package/lib/plugins/vue-tsx.js

@@ -198,9 +198,10 @@ function createTsx(fileName, sfc, ctx) {
         };
     });
     return {
+        getLang,
         getScriptRanges,
         getScriptSetupRanges,
-        getLang,
+        getSetupSlotsAssignName,
         getGeneratedScript,
         getGeneratedTemplate,
     };

package/lib/types.d.ts

@@ -6,9 +6,10 @@ import type * as ts from 'typescript';
 import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
 export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
-export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
+export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>> & {
     strictTemplates?: boolean;
     target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
+    globalTypesPath?: string;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -19,12 +20,11 @@ export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
     target: number;
     lib: string;
-    globalTypesPath?: string;
+    globalTypesPath: (fileName: string) => string | void;
     extensions: string[];
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
-    strictSlotChildren: boolean;
     strictVModel: boolean;
     strictCssModules: boolean;
     checkUnknownProps: boolean;

package/lib/utils/collectBindings.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+export declare function collectBindingNames(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string[];
+export declare function collectBindingRanges(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): import("../types").TextRange[];
+export declare function collectBindingIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];

package/lib/utils/collectBindings.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectBindingNames = collectBindingNames;
+exports.collectBindingRanges = collectBindingRanges;
+exports.collectBindingIdentifiers = collectBindingIdentifiers;
+const shared_1 = require("./shared");
+function collectBindingNames(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getNodeText)(ts, id, ast));
+}
+function collectBindingRanges(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getStartEnd)(ts, id, ast));
+}
+function collectBindingIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
+    if (ts.isIdentifier(node)) {
+        results.push({ id: node, isRest, initializer });
+    }
+    else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectBindingIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectBindingIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+//# sourceMappingURL=collectBindings.js.map

package/lib/utils/ts.d.ts

@@ -10,12 +10,14 @@ export declare function createParsedCommandLine(ts: typeof import('typescript'),
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
     configRoots: Set<string>;
-    options: Omit<RawVueCompilerOptions, 'target' | 'plugin'>;
+    options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
     target: number | undefined;
     globalTypesPath: string | undefined;
     plugins: VueLanguagePlugin[];
     constructor(fileExists?: ((path: string) => boolean) | undefined);
     addConfig(options: RawVueCompilerOptions, rootDir: string): void;
     build(defaults?: VueCompilerOptions): VueCompilerOptions;
+    private findNodeModulesRoot;
 }
 export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
+export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;

package/lib/utils/ts.js

@@ -4,6 +4,7 @@ exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
+exports.writeGlobalTypes = writeGlobalTypes;
 const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("../codegen/globalTypes");
@@ -178,25 +179,38 @@ class CompilerOptionsResolver {
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
         };
-        if (this.fileExists && this.globalTypesPath === undefined) {
-            root: for (const rootDir of [...this.configRoots].reverse()) {
-                let dir = rootDir;
-                while (!this.fileExists(path_browserify_1.posix.join(dir, 'node_modules', resolvedOptions.lib, 'package.json'))) {
-                    const parentDir = path_browserify_1.posix.dirname(dir);
-                    if (dir === parentDir) {
-                        continue root;
+        if (resolvedOptions.globalTypesPath === shared_1.NOOP) {
+            if (this.fileExists && this.globalTypesPath === undefined) {
+                const fileDirToGlobalTypesPath = new Map();
+                resolvedOptions.globalTypesPath = fileName => {
+                    const fileDir = path_browserify_1.posix.dirname(fileName);
+                    if (fileDirToGlobalTypesPath.has(fileDir)) {
+                        return fileDirToGlobalTypesPath.get(fileDir);
                     }
-                    dir = parentDir;
-                }
-                resolvedOptions.globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions));
-                break;
+                    const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
+                    const result = root
+                        ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
+                        : undefined;
+                    fileDirToGlobalTypesPath.set(fileDir, result);
+                    return result;
+                };
+            }
+            else {
+                resolvedOptions.globalTypesPath = () => this.globalTypesPath;
             }
-        }
-        else {
-            resolvedOptions.globalTypesPath = this.globalTypesPath;
         }
         return resolvedOptions;
     }
+    findNodeModulesRoot(dir, lib) {
+        while (!this.fileExists(path_browserify_1.posix.join(dir, 'node_modules', lib, 'package.json'))) {
+            const parentDir = path_browserify_1.posix.dirname(dir);
+            if (dir === parentDir) {
+                return;
+            }
+            dir = parentDir;
+        }
+        return dir;
+    }
 }
 exports.CompilerOptionsResolver = CompilerOptionsResolver;
 function findVueVersion(rootDir) {
@@ -227,11 +241,11 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
     return {
         target,
         lib,
+        globalTypesPath: shared_1.NOOP,
         extensions: ['.vue'],
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
-        strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
         strictCssModules: false,
         checkUnknownProps: strictTemplates,
@@ -287,4 +301,19 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         },
     };
 }
+function writeGlobalTypes(vueOptions, writeFile) {
+    const originalFn = vueOptions.globalTypesPath;
+    if (!originalFn) {
+        return;
+    }
+    const writed = new Set();
+    vueOptions.globalTypesPath = (fileName) => {
+        const result = originalFn(fileName);
+        if (result && !writed.has(result)) {
+            writed.add(result);
+            writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));
+        }
+        return result;
+    };
+}
 //# sourceMappingURL=ts.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.2",
+	"version": "3.0.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.19",
+		"@volar/language-core": "2.4.20",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
@@ -26,7 +26,7 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
 		"@types/picomatch": "^4.0.0",
-		"@volar/typescript": "2.4.19",
+		"@volar/typescript": "2.4.20",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "7343119e9ca4f6a54f63b57f448f15df4b592a9a"
+	"gitHead": "148d386f9779c2de64cdcbd35310e03b36943b05"
 }