@vue/language-core 2.0.13 → 2.0.15

package/index.d.ts

@@ -1,4 +1,4 @@
-export * from './lib/generators/template';
+export * from './lib/codegen/template';
 export * from './lib/languageModule';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';

package/index.js

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

package/lib/codegen/common.d.ts

@@ -0,0 +1,11 @@
+import type * as ts from 'typescript';
+import type { Code, SfcBlock, VueCodeInformation } from '../types';
+export declare const newLine = "\n";
+export declare const endOfLine = ";\n";
+export declare const combineLastMapping: VueCodeInformation;
+export declare const variableNameRegex: RegExp;
+export declare function conditionWrapWith(condition: boolean, startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, result: string[]): void;
+export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
+export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

package/lib/codegen/common.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSfcBlockSection = exports.createTsAst = exports.collectVars = exports.wrapWith = exports.conditionWrapWith = exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+exports.newLine = '\n';
+exports.endOfLine = `;${exports.newLine}`;
+exports.combineLastMapping = { __combineLastMapping: true };
+exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+function* conditionWrapWith(condition, startOffset, endOffset, features, ...wrapCodes) {
+    if (condition) {
+        yield* wrapWith(startOffset, endOffset, features, ...wrapCodes);
+    }
+    else {
+        for (const wrapCode of wrapCodes) {
+            yield wrapCode;
+        }
+    }
+}
+exports.conditionWrapWith = conditionWrapWith;
+function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
+    yield ['', 'template', startOffset, features];
+    let offset = 1;
+    for (const wrapCode of wrapCodes) {
+        if (typeof wrapCode !== 'string') {
+            offset++;
+        }
+        yield wrapCode;
+    }
+    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
+}
+exports.wrapWith = wrapWith;
+function collectVars(ts, node, ast, result) {
+    if (ts.isIdentifier(node)) {
+        result.push((0, scriptSetupRanges_1.getNodeText)(ts, node, ast));
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectVars(ts, el.name, ast, result);
+        }
+    }
+    else if (ts.isArrayBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectVars(ts, el.name, ast, result);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectVars(ts, node, ast, result));
+    }
+}
+exports.collectVars = collectVars;
+function createTsAst(ts, astHolder, text) {
+    if (astHolder.__volar_ast_text !== text) {
+        astHolder.__volar_ast_text = text;
+        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+    }
+    return astHolder.__volar_ast;
+}
+exports.createTsAst = createTsAst;
+function generateSfcBlockSection(block, start, end, features) {
+    return [
+        block.content.substring(start, end),
+        block.name,
+        start,
+        features,
+    ];
+}
+exports.generateSfcBlockSection = generateSfcBlockSection;
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1,9 @@
+import type { ScriptRanges } from '../../parsers/scriptRanges';
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateScriptOptions(script: NonNullable<Sfc['script']>, scriptRanges: ScriptRanges): Generator<Code>;
+export declare function generateScriptSetupOptions(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/component.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScriptSetupOptions = exports.generateScriptOptions = exports.generateComponentSetupReturns = exports.generateComponent = void 0;
+const common_1 = require("../common");
+const index_1 = require("./index");
+function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (options.sfc.script && options.scriptRanges?.exportDefault && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
+        // use defineComponent() from user space code if it exist
+        yield (0, common_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, index_1.codeFeatures.all);
+        yield `{${common_1.newLine}`;
+    }
+    else {
+        yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+    }
+    yield `setup() {${common_1.newLine}`;
+    yield `return {${common_1.newLine}`;
+    if (ctx.bypassDefineComponent) {
+        yield* generateComponentSetupReturns(scriptSetupRanges);
+    }
+    if (scriptSetupRanges.expose.define) {
+        yield `...__VLS_exposed,${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `},${common_1.newLine}`;
+    if (!ctx.bypassDefineComponent) {
+        yield* generateScriptSetupOptions(options, ctx, scriptSetup, scriptSetupRanges);
+    }
+    if (options.sfc.script && options.scriptRanges) {
+        yield* generateScriptOptions(options.sfc.script, options.scriptRanges);
+    }
+    yield `})`;
+}
+exports.generateComponent = generateComponent;
+function* generateComponentSetupReturns(scriptSetupRanges) {
+    // fill $props
+    if (scriptSetupRanges.props.define) {
+        // NOTE: defineProps is inaccurate for $props
+        yield `$props: __VLS_makeOptional(${scriptSetupRanges.props.name ?? `__VLS_props`}),${common_1.newLine}`;
+        yield `...${scriptSetupRanges.props.name ?? `__VLS_props`},${common_1.newLine}`;
+    }
+    // fill $emit
+    if (scriptSetupRanges.emits.define) {
+        yield `$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
+    }
+}
+exports.generateComponentSetupReturns = generateComponentSetupReturns;
+function* generateScriptOptions(script, scriptRanges) {
+    if (scriptRanges.exportDefault?.args) {
+        yield (0, common_1.generateSfcBlockSection)(script, scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1, index_1.codeFeatures.all);
+    }
+}
+exports.generateScriptOptions = generateScriptOptions;
+function* generateScriptSetupOptions(options, ctx, scriptSetup, scriptSetupRanges) {
+    const propsCodegens = [];
+    if (ctx.generatedPropsType) {
+        propsCodegens.push(function* () {
+            yield `{} as `;
+            if (scriptSetupRanges.props.withDefaults?.arg) {
+                yield `${ctx.helperTypes.WithDefaults.name}<`;
+            }
+            yield `${ctx.helperTypes.TypePropsToOption.name}<`;
+            yield `__VLS_PublicProps>`;
+            if (scriptSetupRanges.props.withDefaults?.arg) {
+                yield `, typeof __VLS_withDefaultsArg>`;
+            }
+        });
+    }
+    if (scriptSetupRanges.props.define?.arg) {
+        const { arg } = scriptSetupRanges.props.define;
+        propsCodegens.push(function* () {
+            yield (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation);
+        });
+    }
+    if (propsCodegens.length === 1) {
+        yield `props: `;
+        for (const generate of propsCodegens) {
+            yield* generate();
+        }
+        yield `,${common_1.newLine}`;
+    }
+    else if (propsCodegens.length >= 2) {
+        yield `props: {${common_1.newLine}`;
+        for (const generate of propsCodegens) {
+            yield `...`;
+            yield* generate();
+            yield `,${common_1.newLine}`;
+        }
+        yield `},${common_1.newLine}`;
+    }
+    if (scriptSetupRanges.defineProp.filter(p => p.isModel).length || scriptSetupRanges.emits.define) {
+        yield `emits: ({} as __VLS_NormalizeEmits<typeof __VLS_modelEmitsType`;
+        if (scriptSetupRanges.emits.define) {
+            yield ` & typeof `;
+            yield scriptSetupRanges.emits.name ?? '__VLS_emit';
+        }
+        yield `>),${common_1.newLine}`;
+    }
+    if (options.vueCompilerOptions.target >= 3.5) {
+        // https://github.com/vuejs/core/pull/10801
+        if (scriptSetupRanges.props.define?.typeArg) {
+            yield `__typeProps: typeof __VLS_typeProps,${common_1.newLine}`;
+        }
+        if (scriptSetupRanges.emits.define?.typeArg) {
+            yield `__typeEmits: typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
+        }
+    }
+}
+exports.generateScriptSetupOptions = generateScriptSetupOptions;
+//# sourceMappingURL=component.js.map

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

@@ -0,0 +1,25 @@
+import type { ScriptCodegenOptions } from './index';
+interface HelperType {
+    name: string;
+    used?: boolean;
+    generated?: boolean;
+    code: string;
+}
+export type ScriptCodegenContext = ReturnType<typeof createScriptCodegenContext>;
+export declare function createScriptCodegenContext(options: ScriptCodegenOptions): {
+    generatedTemplate: boolean;
+    generatedPropsType: boolean;
+    scriptSetupGeneratedOffset: number | undefined;
+    bypassDefineComponent: boolean;
+    bindingNames: Set<string>;
+    helperTypes: {
+        OmitKeepDiscriminatedUnion: HelperType;
+        WithDefaults: HelperType;
+        Prettify: HelperType;
+        WithTemplateSlots: HelperType;
+        PropsChildren: HelperType;
+        TypePropsToOption: HelperType;
+    };
+    generateHelperTypes: () => Generator<string, void, unknown>;
+};
+export {};

package/lib/codegen/script/context.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScriptCodegenContext = void 0;
+const shared_1 = require("../../utils/shared");
+const common_1 = require("../common");
+function createScriptCodegenContext(options) {
+    const helperTypes = {
+        OmitKeepDiscriminatedUnion: {
+            get name() {
+                this.used = true;
+                return `__VLS_OmitKeepDiscriminatedUnion`;
+            },
+            get code() {
+                return `type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
+					? Pick<T, Exclude<keyof T, K>>
+					: never;`;
+            },
+        },
+        WithDefaults: {
+            get name() {
+                this.used = true;
+                return `__VLS_WithDefaults`;
+            },
+            get code() {
+                return `type __VLS_WithDefaults<P, D> = {
+					[K in keyof Pick<P, keyof P>]: K extends keyof D
+						? ${helperTypes.Prettify.name}<P[K] & { default: D[K]}>
+						: P[K]
+				};`;
+            },
+        },
+        Prettify: {
+            get name() {
+                this.used = true;
+                return `__VLS_Prettify`;
+            },
+            get code() {
+                return `type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};`;
+            },
+        },
+        WithTemplateSlots: {
+            get name() {
+                this.used = true;
+                return `__VLS_WithTemplateSlots`;
+            },
+            get code() {
+                return `type __VLS_WithTemplateSlots<T, S> = T & {
+					new(): {
+						${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: S;
+						${options.vueCompilerOptions.jsxSlots ? `$props: ${helperTypes.PropsChildren.name}<S>;` : ''}
+					}
+				};`;
+            },
+        },
+        PropsChildren: {
+            get name() {
+                this.used = true;
+                return `__VLS_PropsChildren`;
+            },
+            get code() {
+                return `type __VLS_PropsChildren<S> = {
+					[K in keyof (
+						boolean extends (
+							// @ts-ignore
+							JSX.ElementChildrenAttribute extends never
+								? true
+								: false
+						)
+							? never
+							// @ts-ignore
+							: JSX.ElementChildrenAttribute
+					)]?: S;
+				};`;
+            },
+        },
+        TypePropsToOption: {
+            get name() {
+                this.used = true;
+                return `__VLS_TypePropsToOption`;
+            },
+            get code() {
+                return options.compilerOptions.exactOptionalPropertyTypes ?
+                    `type __VLS_TypePropsToOption<T> = {
+						[K in keyof T]-?: {} extends Pick<T, K>
+							? { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]> }
+							: { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+					};` :
+                    `type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+					type __VLS_TypePropsToOption<T> = {
+						[K in keyof T]-?: {} extends Pick<T, K>
+							? { type: import('${options.vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
+							: { type: import('${options.vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+					};`;
+            },
+        },
+    };
+    return {
+        generatedTemplate: false,
+        generatedPropsType: false,
+        scriptSetupGeneratedOffset: undefined,
+        bypassDefineComponent: options.lang === 'js' || options.lang === 'jsx',
+        bindingNames: new Set([
+            ...options.scriptRanges?.bindings.map(range => options.sfc.script.content.substring(range.start, range.end)) ?? [],
+            ...options.scriptSetupRanges?.bindings.map(range => options.sfc.scriptSetup.content.substring(range.start, range.end)) ?? [],
+        ]),
+        helperTypes,
+        generateHelperTypes,
+    };
+    function* generateHelperTypes() {
+        let shouldCheck = true;
+        while (shouldCheck) {
+            shouldCheck = false;
+            for (const helperType of Object.values(helperTypes)) {
+                if (helperType.used && !helperType.generated) {
+                    shouldCheck = true;
+                    helperType.generated = true;
+                    yield common_1.newLine + helperType.code + common_1.newLine;
+                }
+            }
+        }
+    }
+}
+exports.createScriptCodegenContext = createScriptCodegenContext;
+//# sourceMappingURL=context.js.map

package/lib/{generators → codegen/script}/globalTypes.d.ts

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

package/lib/codegen/script/globalTypes.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGlobalTypes = void 0;
+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 global {
+	// @ts-ignore
+	type __VLS_IntrinsicElements = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.IntrinsicElements, __VLS_PickNotAny<globalThis.JSX.IntrinsicElements, Record<string, any>>>;
+	// @ts-ignore
+	type __VLS_Element = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.Element, globalThis.JSX.Element>;
+	// @ts-ignore
+	type __VLS_GlobalComponents = ${[
+        `__VLS_PickNotAny<import('vue').GlobalComponents, {}>`,
+        `__VLS_PickNotAny<import('@vue/runtime-core').GlobalComponents, {}>`,
+        `__VLS_PickNotAny<import('@vue/runtime-dom').GlobalComponents, {}>`,
+        `Pick<typeof import('${vueCompilerOptions.lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>`
+    ].join(' & ')};
+	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];
+	function __VLS_directiveFunction<T>(dir: T):
+		T extends import('${vueCompilerOptions.lib}').ObjectDirective<infer E, infer V> | import('${vueCompilerOptions.lib}').FunctionDirective<infer E, infer V> ? (value: V) => void
+		: T;
+	function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+
+	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 }'}
+
+	type __VLS_FillingEventArg_ParametersLength<E extends (...args: any) => any> = __VLS_IsAny<Parameters<E>> extends true ? -1 : Parameters<E>['length'];
+	type __VLS_FillingEventArg<E> = E extends (...args: any) => any ? __VLS_FillingEventArg_ParametersLength<E> extends 0 ? ($event?: undefined) => ReturnType<E> : E : E;
+	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_pickEvent<E1, E2>(emitEvent: E1, propEvent: E2): __VLS_FillingEventArg<
+		__VLS_PickNotAny<
+			__VLS_AsFunctionOrAny<E2>,
+			__VLS_AsFunctionOrAny<E1>
+		>
+	> | undefined;
+	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_AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
+
+	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+
+	/**
+	 * 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]; } & {};
+}
+export const __VLS_globalTypesEnd = {};`;
+}
+exports.generateGlobalTypes = generateGlobalTypes;
+;
+//# sourceMappingURL=globalTypes.js.map

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

@@ -0,0 +1,33 @@
+import type { Mapping } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { ScriptRanges } from '../../parsers/scriptRanges';
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+export declare const codeFeatures: {
+    all: VueCodeInformation;
+    none: VueCodeInformation;
+    verification: VueCodeInformation;
+    navigation: VueCodeInformation;
+    referencesCodeLens: VueCodeInformation;
+    cssClassNavigation: VueCodeInformation;
+};
+export interface ScriptCodegenOptions {
+    fileBaseName: string;
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    sfc: Sfc;
+    lang: string;
+    scriptRanges: ScriptRanges | undefined;
+    scriptSetupRanges: ScriptSetupRanges | undefined;
+    templateCodegen: {
+        tsCodes: Code[];
+        ctx: TemplateCodegenContext;
+        hasSlot: boolean;
+    } | undefined;
+    globalTypes: boolean;
+    getGeneratedLength: () => number;
+    linkedCodeMappings: Mapping[];
+}
+export declare function generateScript(options: ScriptCodegenOptions): Generator<Code>;