@vue/language-core 2.1.2 → 2.1.4

package/lib/codegen/globalTypes.d.ts

@@ -1 +1 @@
-export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;
+export declare function generateGlobalTypes(mode: 'global' | 'local', lib: string, target: number, strictTemplates: boolean): string;

package/lib/codegen/globalTypes.js

@@ -2,13 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateGlobalTypes = generateGlobalTypes;
 const shared_1 = require("../utils/shared");
-function generateGlobalTypes(lib, target, strictTemplates) {
+const common_1 = require("./common");
+function generateGlobalTypes(mode, lib, target, strictTemplates) {
     const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${strictTemplates ? '' : ' & Record<string, unknown>'}`;
-    return `
-const __VLS_globalComponents = { ...{} as import('${lib}').GlobalComponents };
-
-declare const __VLS_intrinsicElements: __VLS_IntrinsicElements;
-declare const __VLS_directiveBindingRestFields = { instance: null, oldValue: null, modifiers: null as any, dir: null as any };
+    let str = '';
+    let globalComponentsType;
+    if (mode === 'global') {
+        str += `// @ts-nocheck${common_1.newLine}`;
+        str += `export {}${common_1.endOfLine}`;
+        str += `declare module '${lib}' {${common_1.newLine}`;
+        str += `	export interface GlobalComponents { }${common_1.newLine}`;
+        str += `}${common_1.newLine}`;
+        str += `declare global {${common_1.newLine}`;
+        globalComponentsType = `import('${lib}').GlobalComponents`;
+    }
+    else {
+        str += `const __VLS_globalComponents = { ...{} as import('${lib}').GlobalComponents }${common_1.endOfLine}`;
+        globalComponentsType = `void extends typeof __VLS_globalComponents ? {} : typeof __VLS_globalComponents`;
+    }
+    str += `
+const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+const __VLS_directiveBindingRestFields = { instance: null, oldValue: null, modifiers: null as any, dir: null as any };
 
 type __VLS_IntrinsicElements = ${(target >= 3.3
         ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements;`
@@ -17,8 +31,8 @@ type __VLS_Element = ${(target >= 3.3
         ? `import('${lib}/jsx-runtime').JSX.Element;`
         : `globalThis.JSX.Element;`)}
 type __VLS_GlobalComponents = ${(target >= 3.5
-        ? `void extends typeof __VLS_globalComponents ? {} : typeof __VLS_globalComponents;`
-        : `(void extends typeof __VLS_globalComponents ? {} : typeof __VLS_globalComponents) & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`)}
+        ? globalComponentsType
+        : `(${globalComponentsType}) & Pick<typeof import('${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;
 type __VLS_unknownDirective = (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
@@ -66,40 +80,40 @@ type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
 >;
 type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
 
-declare function __VLS_getVForSourceType(source: number): [number, number, number][];
-declare function __VLS_getVForSourceType(source: string): [string, number, number][];
-declare function __VLS_getVForSourceType<T extends any[]>(source: T): [
+function __VLS_getVForSourceType(source: number): [number, number, number][];
+function __VLS_getVForSourceType(source: string): [string, number, number][];
+function __VLS_getVForSourceType<T extends any[]>(source: T): [
 	item: T[number],
 	key: number,
 	index: number,
 ][];
-declare function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
 	item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
 	key: number,
 	index: undefined,
 ][];
 // #3845
-declare function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
 	item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
 	key: number,
 	index: undefined,
 ][];
-declare function __VLS_getVForSourceType<T>(source: T): [
+function __VLS_getVForSourceType<T>(source: T): [
 	item: T[keyof T],
 	key: keyof T,
 	index: number,
 ][];
 // @ts-ignore
-declare function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
 // @ts-ignore
-declare function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
-declare function __VLS_directiveAsFunction<T extends import('${lib}').Directive>(dir: T): T extends (...args: any) => any
+function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+function __VLS_directiveAsFunction<T extends import('${lib}').Directive>(dir: T): T extends (...args: any) => any
 	? T | __VLS_unknownDirective
 	: NonNullable<(T & Record<string, __VLS_unknownDirective>)['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>;
-declare function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
-declare function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
-declare function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
-declare function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
+function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
 	T extends new (...args: any) => any
 	? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & { __ctx?: {
 		attrs?: any,
@@ -109,15 +123,19 @@ declare function __VLS_asFunctionalComponent<T, K = T extends new (...args: any)
 	: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
 	: T extends (...args: any) => any ? T
 	: (_: {}${strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${strictTemplates ? '' : ' & Record<string, unknown>'} } };
-declare function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
-declare function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
-declare function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): NonNullable<__VLS_PickNotAny<
+function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
+function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: 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
 >>;
-declare function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
-declare function __VLS_tryAsConstant<const T>(t: T): T;
+function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+function __VLS_tryAsConstant<const T>(t: T): T;
 `;
+    if (mode === 'global') {
+        str += `}${common_1.newLine}`;
+    }
+    return str;
 }
 ;
 //# sourceMappingURL=globalTypes.js.map

package/lib/codegen/localTypes.d.ts

@@ -10,5 +10,4 @@ export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptio
     readonly PropsChildren: string;
     readonly TypePropsToOption: string;
     readonly OmitIndexSignature: string;
-    readonly PickRefsExpose: string;
 };

package/lib/codegen/localTypes.js

@@ -58,15 +58,6 @@ type __VLS_TypePropsToOption<T> = {
 };
 `.trimStart());
     const OmitIndexSignature = defineHelper(`__VLS_OmitIndexSignature`, () => `type __VLS_OmitIndexSignature<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K]; }${common_1.endOfLine}`);
-    const PickRefsExpose = defineHelper(`__VLS_PickRefsExpose`, () => `
-type __VLS_PickRefsExpose<T> = T extends object
-	? { [K in keyof T]: (T[K] extends any[]
-	? Parameters<T[K][0]['expose']>[0][]
-	: T[K] extends { expose?: (exposed: infer E) => void }
-	? E
-	: T[K]) | null }
-	: never;
-`.trimStart());
     const helpers = {
         [PrettifyLocal.name]: PrettifyLocal,
         [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
@@ -75,7 +66,6 @@ type __VLS_PickRefsExpose<T> = T extends object
         [PropsChildren.name]: PropsChildren,
         [TypePropsToOption.name]: TypePropsToOption,
         [OmitIndexSignature.name]: OmitIndexSignature,
-        [PickRefsExpose.name]: PickRefsExpose,
     };
     used.clear();
     return {
@@ -90,7 +80,6 @@ type __VLS_PickRefsExpose<T> = T extends object
         get PropsChildren() { return PropsChildren.name; },
         get TypePropsToOption() { return TypePropsToOption.name; },
         get OmitIndexSignature() { return OmitIndexSignature.name; },
-        get PickRefsExpose() { return PickRefsExpose.name; },
     };
     function* generate(names) {
         const generated = new Set();

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

@@ -23,7 +23,6 @@ export declare function createScriptCodegenContext(options: ScriptCodegenOptions
         readonly PropsChildren: string;
         readonly TypePropsToOption: string;
         readonly OmitIndexSignature: string;
-        readonly PickRefsExpose: string;
     };
     inlayHints: InlayHintInfo[];
 };

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

@@ -0,0 +1,2 @@
+import type { VueCompilerOptions } from '../../types';
+export declare function generateGlobalTypes(vueCompilerOptions: VueCompilerOptions): string;

package/lib/codegen/script/globalTypes.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGlobalTypes = generateGlobalTypes;
+const shared_1 = require("../../utils/shared");
+function generateGlobalTypes(vueCompilerOptions) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}`;
+    return `export const __VLS_globalTypesStart = {};
+declare module '${vueCompilerOptions.lib}' {
+	interface GlobalComponents {}
+}
+declare global {
+	type __VLS_IntrinsicElements = ${vueCompilerOptions.target >= 3.3
+        ? `import('${vueCompilerOptions.lib}/jsx-runtime').JSX.IntrinsicElements;`
+        : `globalThis.JSX.IntrinsicElements;`}
+	type __VLS_Element = ${vueCompilerOptions.target >= 3.3
+        ? `import('${vueCompilerOptions.lib}/jsx-runtime').JSX.Element;`
+        : `globalThis.JSX.Element;`}
+	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;
+
+	const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+
+	// v-for
+	function __VLS_getVForSourceType(source: number): [number, number, number][];
+	function __VLS_getVForSourceType(source: string): [string, number, number][];
+	function __VLS_getVForSourceType<T extends any[]>(source: T): [
+		item: T[number],
+		key: number,
+		index: number,
+	][];
+	function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
+		key: number,
+		index: undefined,
+	][];
+	// #3845
+	function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
+		key: number,
+		index: undefined,
+	][];
+	function __VLS_getVForSourceType<T>(source: T): [
+		item: T[keyof T],
+		key: keyof T,
+		index: number,
+	][];
+
+	// @ts-ignore
+	function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+	// @ts-ignore
+	function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+
+	// Custom Directives
+	type __VLS_unknownDirective = (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
+	function __VLS_directiveAsFunction<T extends import('${vueCompilerOptions.lib}').Directive>(dir: T): T extends (...args: any) => any
+	  ? T | __VLS_unknownDirective
+		: NonNullable<(T & Record<string, __VLS_unknownDirective>)['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>;
+	const __VLS_directiveBindingRestFields = { instance: null, oldValue: null, modifiers: null as any, dir: null as any };
+
+	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> =
+		N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N1] } :
+		N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N2] } :
+		N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N3] } :
+		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] } :
+		${vueCompilerOptions.strictTemplates ? '{}' : '{ [K in N0]: unknown }'}
+
+	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)(vueCompilerOptions.target)}: infer Slots } ? Slots : any,
+			emit?: K extends { $emit: infer Emit } ? Emit : any
+		} & { props?: ${fnPropsType}; expose?(exposed: K): void; } }
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		: T extends (...args: any) => any ? T
+		: (_: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'} } };
+	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+	function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __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_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_IsFunction<T, K> = K extends keyof T
+		? __VLS_IsAny<T[K]> extends false
+		? unknown extends T[K]
+		? false
+		: true
+		: false
+		: false;
+
+	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+	function __VLS_tryAsConstant<const T>(t: T): T;
+
+	/**
+	 * emit
+	 */
+	// 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
+		? U extends T
+		? never
+		: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
+		: never;
+	type __VLS_OverloadUnion<T> = Exclude<
+		__VLS_OverloadUnionInner<(() => never) & T>,
+		T extends () => never ? never : () => never
+	>;
+	type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
+		? F extends (event: infer E, ...args: infer A) => any
+		? { [K in E & string]: (...args: A) => void; }
+		: never
+		: never;
+	type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
+		__VLS_UnionToIntersection<
+			__VLS_ConstructorOverloads<T> & {
+				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+			}
+		>
+	>;
+	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+	type __VLS_PickRefsExpose<T> = T extends object
+		? { [K in keyof T]: (T[K] extends any[]
+		? Parameters<T[K][0]['expose']>[0][]
+		: T[K] extends { expose?: (exposed: infer E) => void }
+		? E
+		: T[K]) | null }
+		: never;
+}
+export const __VLS_globalTypesEnd = {};
+`;
+}
+;
+//# sourceMappingURL=globalTypes.js.map

package/lib/codegen/script/index.js

@@ -7,6 +7,7 @@ const context_1 = require("./context");
 const scriptSetup_1 = require("./scriptSetup");
 const src_1 = require("./src");
 const template_1 = require("./template");
+const globalTypes_1 = require("../globalTypes");
 exports.codeFeatures = {
     all: {
         verification: true,
@@ -31,7 +32,12 @@ exports.codeFeatures = {
 };
 function* generateScript(options) {
     const ctx = (0, context_1.createScriptCodegenContext)(options);
-    yield `/// <reference types="${options.vueCompilerOptions.lib}/dist/__globalTypes_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${common_1.newLine}`;
+    if (options.vueCompilerOptions.__setupedGlobalTypes?.()) {
+        yield `/// <reference types=".vue-global-types/${options.vueCompilerOptions.lib}_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${common_1.newLine}`;
+    }
+    else {
+        yield `/* placeholder */`;
+    }
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script, options.sfc.script.src);
     }
@@ -112,6 +118,9 @@ function* generateScript(options) {
         yield `type __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${common_1.endOfLine}`;
     }
     yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
+    if (!options.vueCompilerOptions.__setupedGlobalTypes?.()) {
+        yield (0, globalTypes_1.generateGlobalTypes)('local', options.vueCompilerOptions.lib, options.vueCompilerOptions.target, options.vueCompilerOptions.strictTemplates);
+    }
     if (options.sfc.scriptSetup) {
         yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
     }

package/lib/codegen/script/internalComponent.js

@@ -40,9 +40,6 @@ function* generateInternalComponent(options, ctx, templateCodegenCtx) {
         }
         yield `}${common_1.endOfLine}`; // return {
         yield `},${common_1.newLine}`; // setup() {
-        if (options.vueCompilerOptions.target >= 3.5) {
-            yield `__typeRefs: {} as __VLS_Refs,${common_1.newLine}`;
-        }
         if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
             const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.sfc.scriptSetup, options.scriptSetupRanges)];
             for (const code of emitOptionCodes) {

package/lib/codegen/script/scriptSetup.js

@@ -221,7 +221,15 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     }
     for (const { define } of scriptSetupRanges.templateRefs) {
         if (define?.arg) {
-            setupCodeModifies.push([[`<__VLS_Refs[${scriptSetup.content.slice(define.arg.start, define.arg.end)}], keyof __VLS_Refs>`], define.arg.start - 1, define.arg.start - 1]);
+            setupCodeModifies.push([
+                [
+                    `<__VLS_Refs[`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.navigation),
+                    `], keyof __VLS_Refs>`
+                ],
+                define.arg.start - 1,
+                define.arg.start - 1
+            ]);
         }
     }
     setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);

package/lib/codegen/script/template.js

@@ -13,20 +13,58 @@ const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const index_1 = require("./index");
 const internalComponent_1 = require("./internalComponent");
 function* generateTemplateCtx(options, isClassComponent) {
-    const types = [];
+    const baseExps = [];
+    const extraExps = [];
     if (isClassComponent) {
-        types.push(`typeof this`);
+        baseExps.push(`this`);
     }
     else {
-        types.push(`InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>>`);
+        baseExps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>>`);
     }
     if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileBaseName.endsWith(ext))) {
-        types.push(`typeof globalThis`);
+        extraExps.push(`globalThis`);
     }
     if (options.sfc.styles.some(style => style.module)) {
-        types.push(`__VLS_StyleModules`);
+        extraExps.push(`{} as __VLS_StyleModules`);
+    }
+    if (options.scriptSetupRanges?.templateRefs.length) {
+        let exp = `{} as import('${options.vueCompilerOptions.lib}').UnwrapRef<{${common_1.newLine}`;
+        for (const { name } of options.scriptSetupRanges.templateRefs) {
+            if (name) {
+                exp += `${name}: typeof ${name}${common_1.newLine}`;
+            }
+        }
+        exp += `}>${common_1.newLine}`;
+        extraExps.push(exp);
+    }
+    yield `const __VLS_ctxBase = `;
+    if (baseExps.length === 1) {
+        yield baseExps[0];
+        yield common_1.endOfLine;
+    }
+    else {
+        yield `{${common_1.newLine}`;
+        for (const exp of baseExps) {
+            yield `...`;
+            yield exp;
+            yield `,${common_1.newLine}`;
+        }
+        yield `}${common_1.endOfLine}`;
+    }
+    yield `const __VLS_ctx = `;
+    if (extraExps.length === 0) {
+        yield `__VLS_ctxBase${common_1.endOfLine}`;
+    }
+    else {
+        yield `{${common_1.newLine}`;
+        yield `...__VLS_ctxBase,${common_1.newLine}`;
+        for (const exp of extraExps) {
+            yield `...`;
+            yield exp;
+            yield `,${common_1.newLine}`;
+        }
+        yield `}${common_1.endOfLine}`;
     }
-    yield `let __VLS_ctx!: ${types.join(' & ')}${common_1.endOfLine}`;
 }
 function* generateTemplateComponents(options) {
     const exps = [];
@@ -57,15 +95,15 @@ function* generateTemplateComponents(options) {
 		}`);
     }
     exps.push(`{} as NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}>`);
-    exps.push(`{} as __VLS_GlobalComponents`);
-    exps.push(`{} as typeof __VLS_ctx`);
-    yield `const __VLS_components = {${common_1.newLine}`;
+    exps.push(`__VLS_ctxBase`);
+    yield `const __VLS_localComponents = {${common_1.newLine}`;
     for (const type of exps) {
         yield `...`;
         yield type;
         yield `,${common_1.newLine}`;
     }
     yield `}${common_1.endOfLine}`;
+    yield `let __VLS_components: typeof __VLS_localComponents & __VLS_GlobalComponents${common_1.endOfLine}`;
 }
 function* generateTemplate(options, ctx, isClassComponent) {
     ctx.generatedTemplate = true;
@@ -76,7 +114,7 @@ function* generateTemplate(options, ctx, isClassComponent) {
         });
         yield* generateTemplateCtx(options, isClassComponent);
         yield* generateTemplateComponents(options);
-        yield* generateTemplateBody(options, ctx, templateCodegenCtx);
+        yield* generateTemplateBody(options, templateCodegenCtx);
         yield* (0, internalComponent_1.generateInternalComponent)(options, ctx, templateCodegenCtx);
     }
     else {
@@ -86,7 +124,7 @@ function* generateTemplate(options, ctx, isClassComponent) {
         yield `const __VLS_templateResult { slots: {}, refs: {}, attrs: {} }${common_1.endOfLine}`;
     }
 }
-function* generateTemplateBody(options, ctx, templateCodegenCtx) {
+function* generateTemplateBody(options, templateCodegenCtx) {
     const firstClasses = new Set();
     yield `let __VLS_styleScopedClasses!: {}`;
     for (let i = 0; i < options.sfc.styles.length; i++) {
@@ -119,13 +157,13 @@ function* generateTemplateBody(options, ctx, templateCodegenCtx) {
         yield `// no template${common_1.newLine}`;
         if (!options.scriptSetupRanges?.slots.define) {
             yield `const __VLS_slots = {}${common_1.endOfLine}`;
-            yield `const __VLS_refs = {}${common_1.endOfLine}`;
+            yield `const $refs = {}${common_1.endOfLine}`;
             yield `const __VLS_inheritedAttrs = {}${common_1.endOfLine}`;
         }
     }
     yield `const __VLS_templateResult = {`;
     yield `slots: ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'},${common_1.newLine}`;
-    yield `refs: __VLS_refs as ${ctx.localTypes.PickRefsExpose}<typeof __VLS_refs>,${common_1.newLine}`;
+    yield `refs: $refs,${common_1.newLine}`;
     yield `attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${common_1.newLine}`;
     yield `}${common_1.endOfLine}`;
 }

package/lib/codegen/template/element.js

@@ -150,9 +150,18 @@ function* generateComponent(options, ctx, node, currentComponent) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
         yield common_1.endOfLine;
     }
-    const refName = yield* generateVScope(options, ctx, node, props);
+    const [refName, offset] = yield* generateVScope(options, ctx, node, props);
     if (refName) {
+        const varName = ctx.getInternalVariable();
+        options.templateRefNames.set(refName, [varName, offset]);
         ctx.usedComponentCtxVars.add(var_defineComponentCtx);
+        yield `var ${varName} = {} as (Parameters<typeof ${var_defineComponentCtx}['expose']>[0] | null)`;
+        if (node.codegenNode?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && node.codegenNode.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION
+            && node.codegenNode.props.properties.some(({ key }) => key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && key.content === 'ref_for')) {
+            yield `[]`;
+        }
+        yield `${common_1.endOfLine}`;
     }
     const usedComponentEventsVar = yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEmit, var_componentEvents);
     if (usedComponentEventsVar) {
@@ -176,18 +185,6 @@ function* generateComponent(options, ctx, node, currentComponent) {
     }
     if (ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
         yield `const ${var_defineComponentCtx} = __VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance})${common_1.endOfLine}`;
-        if (refName) {
-            yield `// @ts-ignore${common_1.newLine}`;
-            if (node.codegenNode?.type === CompilerDOM.NodeTypes.VNODE_CALL
-                && node.codegenNode.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION
-                && node.codegenNode.props.properties.find(({ key }) => key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && key.content === 'ref_for')) {
-                yield `(${refName} ??= []).push(${var_defineComponentCtx})`;
-            }
-            else {
-                yield `${refName} = ${var_defineComponentCtx}`;
-            }
-            yield common_1.endOfLine;
-        }
     }
 }
 function* generateElement(options, ctx, node, currentComponent, componentCtxVar) {
@@ -209,12 +206,9 @@ function* generateElement(options, ctx, node, currentComponent, componentCtxVar)
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
         yield common_1.endOfLine;
     }
-    const refName = yield* generateVScope(options, ctx, node, node.props);
+    const [refName, offset] = yield* generateVScope(options, ctx, node, node.props);
     if (refName) {
-        yield `// @ts-ignore${common_1.newLine}`;
-        yield `${refName} = __VLS_intrinsicElements`;
-        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag);
-        yield common_1.endOfLine;
+        options.templateRefNames.set(refName, [`__VLS_intrinsicElements['${node.tag}']`, offset]);
     }
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     if (slotDir && componentCtxVar) {
@@ -249,13 +243,13 @@ function* generateVScope(options, ctx, node, props) {
         inScope = true;
     }
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
-    const refName = yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
+    const [refName, offset] = yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
     yield* generateReferencesForScopedCssClasses(options, ctx, node);
     if (inScope) {
         yield `}${common_1.newLine}`;
         ctx.blockConditions.length = originalConditionsNum;
     }
-    return refName;
+    return [refName, offset];
 }
 function getCanonicalComponentName(tagText) {
     return common_1.variableNameRegex.test(tagText)
@@ -373,11 +367,10 @@ function* generateReferencesForElements(options, ctx, node) {
             if (common_1.variableNameRegex.test(content)) {
                 ctx.accessExternalVariable(content, startOffset);
             }
-            const refName = CompilerDOM.toValidAssetId(prop.value.content, '_VLS_refs');
-            options.templateRefNames.set(prop.value.content, refName);
-            return refName;
+            return [content, startOffset];
         }
     }
+    return [];
 }
 function* generateReferencesForScopedCssClasses(options, ctx, node) {
     for (const prop of node.props) {

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

@@ -10,7 +10,7 @@ export interface TemplateCodegenOptions {
     scriptSetupBindingNames: Set<string>;
     scriptSetupImportComponentNames: Set<string>;
     edited: boolean;
-    templateRefNames: Map<string, string>;
+    templateRefNames: Map<string, [varName: string, offset: number]>;
     hasDefineSlots?: boolean;
     slotsAssignName?: string;
     propsAssignName?: string;

package/lib/codegen/template/index.js

@@ -7,6 +7,7 @@ const common_1 = require("../common");
 const context_1 = require("./context");
 const element_1 = require("./element");
 const objectProperty_1 = require("./objectProperty");
+const stringLiteralKey_1 = require("./stringLiteralKey");
 const templateChild_1 = require("./templateChild");
 const styleScopedClasses_1 = require("./styleScopedClasses");
 function* generateTemplate(options) {
@@ -17,6 +18,7 @@ function* generateTemplate(options) {
     if (options.propsAssignName) {
         ctx.addLocalVariable(options.propsAssignName);
     }
+    ctx.addLocalVariable('$refs');
     yield* generatePreResolveComponents();
     if (options.template.ast) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined, undefined, undefined);
@@ -32,14 +34,13 @@ function* generateTemplate(options) {
     yield* generateRefs();
     return ctx;
     function* generateRefs() {
-        for (const [, validId] of options.templateRefNames) {
-            yield `let ${validId}${common_1.newLine}`;
-        }
         yield `const __VLS_refs = {${common_1.newLine}`;
-        for (const [name, validId] of options.templateRefNames) {
-            yield `'${name}': ${validId}!,${common_1.newLine}`;
+        for (const [name, [varName, offset]] of options.templateRefNames) {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(name, offset, ctx.codeFeatures.navigationAndCompletion);
+            yield `: ${varName},${common_1.newLine}`;
         }
         yield `}${common_1.endOfLine}`;
+        yield `declare var $refs: typeof __VLS_refs${common_1.endOfLine}`;
     }
     function* generateSlotsType() {
         for (const { expVar, varName } of ctx.dynamicSlots) {
@@ -80,7 +81,7 @@ function* generateTemplate(options) {
                     }
                     components.add(node.tag);
                     yield common_1.newLine;
-                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_components, `;
+                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
                     yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
                         .map(name => `"${name}"`)
                         .join(', ');

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

@@ -0,0 +1,3 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { InlayHintInfo } from "../types";
+export declare function generateVBindShorthandInlayHint(loc: CompilerDOM.SourceLocation, variableName: string): InlayHintInfo;

package/lib/codegen/template/vBindShorthand.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVBindShorthandInlayHint = generateVBindShorthandInlayHint;
+function generateVBindShorthandInlayHint(loc, variableName) {
+    return {
+        blockName: 'template',
+        offset: loc.end.offset,
+        setting: 'vue.inlayHints.vBindShorthand',
+        label: `="${variableName}"`,
+        tooltip: [
+            `This is a shorthand for \`${loc.source}="${variableName}"\`.`,
+            'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
+            '[More info](https://github.com/vuejs/core/pull/9451)',
+        ].join('\n\n'),
+    };
+}
+;
+//# sourceMappingURL=vBindShorthand.js.map

package/lib/parsers/scriptSetupRanges.js

@@ -19,10 +19,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
     const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
-    const bindings = parseBindingRanges(ts, ast);
     const text = ast.text;
     const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
     const importComponentNames = new Set();
+    let bindings = parseBindingRanges(ts, ast);
     ts.forEachChild(ast, node => {
         const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
         if (!foundNonImportExportNode
@@ -51,6 +51,11 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         }
     });
     ts.forEachChild(ast, child => visitNode(child, [ast]));
+    const templateRefNames = new Set(templateRefs.map(ref => ref.name));
+    bindings = bindings.filter(range => {
+        const name = text.substring(range.start, range.end);
+        return !templateRefNames.has(name);
+    });
     return {
         leadingCommentEndOffset,
         importSectionEndOffset,

package/lib/plugins/vue-template-html.js

@@ -1,18 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const shouldAddSuffix = /(?<=<[^>/]+)$/;
 const plugin = ({ modules }) => {
     return {
         version: 2.1,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
                 const compiler = modules['@vue/compiler-dom'];
-                return compiler.compile(template, {
+                let addedSuffix = false;
+                // #4583
+                if (shouldAddSuffix.test(template)) {
+                    template += '>';
+                    addedSuffix = true;
+                }
+                const result = compiler.compile(template, {
                     ...options,
                     comments: true,
                 });
+                // @ts-expect-error
+                result.__addedSuffix = addedSuffix;
+                return result;
             }
         },
         updateSFCTemplate(oldResult, change) {
+            oldResult.code = oldResult.code.slice(0, change.start)
+                + change.newText
+                + oldResult.code.slice(change.end);
+            // @ts-expect-error
+            if (oldResult.__addedSuffix) {
+                const originalTemplate = oldResult.code.slice(0, -1); // remove added '>'
+                if (!shouldAddSuffix.test(originalTemplate)) {
+                    return undefined;
+                }
+            }
             const CompilerDOM = modules['@vue/compiler-dom'];
             const lengthDiff = change.newText.length - (change.end - change.start);
             let hitNodes = [];
@@ -107,8 +127,16 @@ const plugin = ({ modules }) => {
                             node.parseResult.key,
                             node.parseResult.index,
                         ]) {
-                            if (child && !tryUpdateNode(child)) {
-                                return false;
+                            if (child) {
+                                if (!tryUpdateNode(child)) {
+                                    return false;
+                                }
+                                if (child.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                                    const content = child.content.trim();
+                                    if (content.startsWith('(') || content.endsWith(')')) {
+                                        return false;
+                                    }
+                                }
                             }
                         }
                         for (const child of node.children) {

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

@@ -101,7 +101,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;
             readonly OmitIndexSignature: string;
-            readonly PickRefsExpose: string;
         };
         inlayHints: import("../codegen/types").InlayHintInfo[];
     };

package/lib/types.d.ts

@@ -45,6 +45,7 @@ export interface VueCompilerOptions {
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
+    __setupedGlobalTypes?: () => boolean;
     __test?: boolean;
 }
 export declare const validVersions: readonly [2, 2.1];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.1.2",
+	"version": "2.1.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "4e4b839ea20ae11a2aef7ee9206465cb60a4be53"
+	"gitHead": "5e197d08eaef57209ff2927c943ba1db3bf4eff6"
 }