@vue/language-core 2.1.4 → 2.1.6

package/lib/plugins/vue-tsx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 const computeds_1 = require("computeds");
-const path = require("path-browserify");
+const path_browserify_1 = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
@@ -10,6 +10,7 @@ const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
 const fileEditTimes = new Map();
 const plugin = ctx => {
+    let appendedGlobalTypes = false;
     return {
         version: 2.1,
         requiredCompilerOptions: [
@@ -38,13 +39,18 @@ const plugin = ctx => {
     };
     function useTsx(fileName, sfc) {
         if (!exports.tsCodegen.has(sfc)) {
-            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
+            let appendGlobalTypes = false;
+            if (!ctx.vueCompilerOptions.__setupedGlobalTypes && !appendedGlobalTypes) {
+                appendGlobalTypes = true;
+                appendedGlobalTypes = true;
+            }
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx, appendGlobalTypes));
         }
         return exports.tsCodegen.get(sfc);
     }
 };
 exports.default = plugin;
-function createTsx(fileName, _sfc, ctx) {
+function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
     const lang = (0, computeds_1.computed)(() => {
         return !_sfc.script && !_sfc.scriptSetup ? 'ts'
@@ -59,7 +65,7 @@ function createTsx(fileName, _sfc, ctx) {
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
         : undefined);
     const generatedTemplate = (0, computeds_1.computed)(() => {
-        if (!_sfc.template) {
+        if (ctx.vueCompilerOptions.skipTemplateCodegen || !_sfc.template) {
             return;
         }
         const codes = [];
@@ -71,7 +77,7 @@ function createTsx(fileName, _sfc, ctx) {
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             scriptSetupBindingNames: scriptSetupBindingNames(),
             scriptSetupImportComponentNames: scriptSetupImportComponentNames(),
-            templateRefNames: new Map(),
+            templateRefNames: templateRefNames(),
             hasDefineSlots: hasDefineSlots(),
             slotsAssignName: slotsAssignName(),
             propsAssignName: propsAssignName(),
@@ -88,7 +94,6 @@ function createTsx(fileName, _sfc, ctx) {
             codes: codes,
         };
     });
-    const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
     const scriptSetupBindingNames = (0, computeds_1.computed)(oldNames => {
         const newNames = new Set();
         const bindings = scriptSetupRanges()?.bindings;
@@ -104,11 +109,21 @@ function createTsx(fileName, _sfc, ctx) {
     });
     const scriptSetupImportComponentNames = (0, computeds_1.computed)(oldNames => {
         const newNames = scriptSetupRanges()?.importComponentNames ?? new Set();
-        if (newNames && oldNames && twoSetsEqual(newNames, oldNames)) {
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
+    const templateRefNames = (0, computeds_1.computed)(oldNames => {
+        const newNames = new Set(scriptSetupRanges()?.templateRefs
+            .map(({ name }) => name)
+            .filter(name => name !== undefined));
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
             return oldNames;
         }
         return newNames;
     });
+    const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
     const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
     const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
     const inheritAttrs = (0, computeds_1.computed)(() => {
@@ -118,21 +133,21 @@ function createTsx(fileName, _sfc, ctx) {
     const generatedScript = (0, computeds_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
-        const _template = generatedTemplate();
         let generatedLength = 0;
         const codegen = (0, script_1.generateScript)({
             ts,
-            fileBaseName: path.basename(fileName),
+            fileBaseName: path_browserify_1.posix.basename(fileName),
             sfc: _sfc,
             lang: lang(),
             scriptRanges: scriptRanges(),
             scriptSetupRanges: scriptSetupRanges(),
-            templateCodegen: _template,
+            templateCodegen: generatedTemplate(),
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
+            appendGlobalTypes,
         });
         fileEditTimes.set(fileName, (fileEditTimes.get(fileName) ?? 0) + 1);
         let current = codegen.next();

package/lib/types.d.ts

@@ -36,16 +36,16 @@ export interface VueCompilerOptions {
         defineModel: string[];
         defineOptions: string[];
         withDefaults: string[];
-        templateRef: string[];
     };
     composibles: {
         useCssModule: string[];
+        useTemplateRef: string[];
     };
     plugins: VueLanguagePlugin[];
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
-    __setupedGlobalTypes?: () => boolean;
+    __setupedGlobalTypes?: boolean;
     __test?: boolean;
 }
 export declare const validVersions: readonly [2, 2.1];

package/lib/utils/ts.d.ts

@@ -3,6 +3,12 @@ import type { VueCompilerOptions } from '../types';
 export type ParsedCommandLine = ts.ParsedCommandLine & {
     vueOptions: VueCompilerOptions;
 };
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost & {
+    writeFile?(path: string, data: string): void;
+}, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
 export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
+export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
+    fileExists(path: string): boolean;
+    writeFile?(path: string, data: string): void;
+}): boolean;

package/lib/utils/ts.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
+exports.setupGlobalTypes = setupGlobalTypes;
 const shared_1 = require("@vue/shared");
-const path = require("path-browserify");
+const path_browserify_1 = require("path-browserify");
 const languagePlugin_1 = require("../languagePlugin");
-function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
+const globalTypes_1 = require("../codegen/globalTypes");
+function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json', skipGlobalTypesSetup = false) {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
     let vueOptions = {};
@@ -20,6 +22,12 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         catch (err) { }
     }
     const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+    if (skipGlobalTypesSetup) {
+        resolvedVueOptions.__setupedGlobalTypes = true;
+    }
+    else {
+        resolvedVueOptions.__setupedGlobalTypes = setupGlobalTypes(rootDir, resolvedVueOptions, parseConfigHost);
+    }
     const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
         .map(extension => ({
         extension: extension.slice(1),
@@ -35,11 +43,11 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         vueOptions: resolvedVueOptions,
     };
 }
-function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
+function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTypesSetup = false) {
     try {
         const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
         const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
-        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath);
+        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath);
         let vueOptions = {};
         for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
             try {
@@ -51,7 +59,13 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
             catch (err) { }
         }
         const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
+        if (skipGlobalTypesSetup) {
+            resolvedVueOptions.__setupedGlobalTypes = true;
+        }
+        else {
+            resolvedVueOptions.__setupedGlobalTypes = setupGlobalTypes(path_browserify_1.posix.dirname(tsConfigPath), resolvedVueOptions, parseConfigHost);
+        }
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
             .map(extension => ({
             extension: extension.slice(1),
             isMixedContent: true,
@@ -97,7 +111,7 @@ function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
     };
 }
 function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
-    const folder = path.dirname(tsConfigSourceFile.fileName);
+    const folder = path_browserify_1.posix.dirname(tsConfigSourceFile.fileName);
     const obj = ts.convertToObject(tsConfigSourceFile, []);
     const rawOptions = obj?.vueCompilerOptions ?? {};
     const result = {
@@ -181,11 +195,12 @@ function resolveVueCompilerOptions(vueOptions) {
             defineModel: ['defineModel'],
             defineOptions: ['defineOptions'],
             withDefaults: ['withDefaults'],
-            templateRef: ['templateRef', 'useTemplateRef'],
             ...vueOptions.macros,
         },
         composibles: {
-            useCssModule: ['useCssModule']
+            useCssModule: ['useCssModule'],
+            useTemplateRef: ['useTemplateRef', 'templateRef'],
+            ...vueOptions.composibles,
         },
         plugins: vueOptions.plugins ?? [],
         // experimental
@@ -205,4 +220,26 @@ function resolveVueCompilerOptions(vueOptions) {
         }).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
     };
 }
+function setupGlobalTypes(rootDir, vueOptions, host) {
+    if (!host.writeFile) {
+        return false;
+    }
+    try {
+        let dir = rootDir;
+        while (!host.fileExists(path_browserify_1.posix.join(dir, 'node_modules', vueOptions.lib, 'package.json'))) {
+            const parentDir = path_browserify_1.posix.dirname(dir);
+            if (dir === parentDir) {
+                throw 0;
+            }
+            dir = parentDir;
+        }
+        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', `${vueOptions.lib}_${vueOptions.target}_${vueOptions.strictTemplates}.d.ts`);
+        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions.lib, vueOptions.target, vueOptions.strictTemplates);
+        host.writeFile(globalTypesPath, globalTypesContents);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=ts.js.map

package/package.json

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

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

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

package/lib/codegen/script/globalTypes.js

@@ -1,147 +0,0 @@
-"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/template/vBindShorthand.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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