@vue/language-core 2.2.0 → 2.2.2

package/index.d.ts

@@ -7,7 +7,6 @@ export * from './lib/types';
 export * from './lib/utils/parseSfc';
 export * from './lib/utils/ts';
 export * from './lib/virtualFile/vueFile';
-export * as scriptRanges from './lib/parsers/scriptRanges';
 export { tsCodegen } from './lib/plugins/vue-tsx';
 export * from './lib/utils/shared';
 export * from '@volar/language-core';

package/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsCodegen = exports.scriptRanges = void 0;
+exports.tsCodegen = void 0;
 __exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
@@ -24,7 +24,6 @@ __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
 __exportStar(require("./lib/utils/ts"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);
-exports.scriptRanges = require("./lib/parsers/scriptRanges");
 var vue_tsx_1 = require("./lib/plugins/vue-tsx");
 Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
 __exportStar(require("./lib/utils/shared"), exports);

package/lib/codeFeatures.d.ts

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

package/lib/codeFeatures.js

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

package/lib/codegen/codeFeatures.d.ts

@@ -0,0 +1,83 @@
+import type { VueCodeInformation } from '../types';
+declare const raw: {
+    all: {
+        verification: true;
+        completion: true;
+        semantic: true;
+        navigation: true;
+    };
+    none: {};
+    verification: {
+        verification: true;
+    };
+    completion: {
+        completion: true;
+    };
+    additionalCompletion: {
+        completion: {
+            isAdditional: true;
+        };
+    };
+    withoutCompletion: {
+        verification: true;
+        semantic: true;
+        navigation: true;
+    };
+    navigation: {
+        navigation: true;
+    };
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename: () => false;
+        };
+    };
+    navigationAndCompletion: {
+        navigation: true;
+        completion: true;
+    };
+    navigationAndAdditionalCompletion: {
+        navigation: true;
+        completion: {
+            isAdditional: true;
+        };
+    };
+    navigationAndVerification: {
+        navigation: true;
+        verification: true;
+    };
+    withoutNavigation: {
+        verification: true;
+        completion: true;
+        semantic: true;
+    };
+    withoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
+    withoutHighlightAndNavigation: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        completion: true;
+    };
+    withoutHighlightAndCompletion: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+    };
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+    };
+};
+export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
+export {};

package/lib/codegen/codeFeatures.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFeatures = void 0;
+const raw = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    none: {},
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    withoutCompletion: {
+        verification: true,
+        semantic: true,
+        navigation: true,
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: { shouldRename: () => false },
+    },
+    navigationAndCompletion: {
+        navigation: true,
+        completion: true,
+    },
+    navigationAndAdditionalCompletion: {
+        navigation: true,
+        completion: { isAdditional: true },
+    },
+    navigationAndVerification: {
+        navigation: true,
+        verification: true,
+    },
+    withoutNavigation: {
+        verification: true,
+        completion: true,
+        semantic: true,
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+exports.codeFeatures = raw;
+//# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/common.d.ts

@@ -0,0 +1,12 @@
+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, results?: string[]): string[];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
+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,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
+exports.conditionWrapWith = conditionWrapWith;
+exports.wrapWith = wrapWith;
+exports.collectVars = collectVars;
+exports.collectIdentifiers = collectIdentifiers;
+exports.createTsAst = createTsAst;
+exports.generateSfcBlockSection = generateSfcBlockSection;
+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;
+        }
+    }
+}
+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 }];
+}
+function collectVars(ts, node, ast, results = []) {
+    const identifiers = collectIdentifiers(ts, node, []);
+    for (const [id] of identifiers) {
+        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+    }
+    return results;
+}
+function collectIdentifiers(ts, node, results = [], isRest = false) {
+    if (ts.isIdentifier(node)) {
+        results.push([node, isRest]);
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+        }
+    }
+    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 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;
+}
+function generateSfcBlockSection(block, start, end, features) {
+    return [
+        block.content.substring(start, end),
+        block.name,
+        start,
+        features,
+    ];
+}
+//# sourceMappingURL=common.js.map

package/lib/codegen/globalTypes.d.ts

@@ -1 +1,3 @@
-export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;
+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;

package/lib/codegen/globalTypes.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalTypesFileName = getGlobalTypesFileName;
 exports.generateGlobalTypes = generateGlobalTypes;
 const shared_1 = require("../utils/shared");
-function generateGlobalTypes(lib, target, strictTemplates) {
-    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${strictTemplates ? '' : ' & Record<string, unknown>'}`;
+function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+    return [
+        lib,
+        target,
+        checkUnknownProps,
+        checkUnknownEvents,
+        checkUnknownComponents,
+    ].map(v => {
+        if (typeof v === 'boolean') {
+            return v ? 1 : 0;
+        }
+        return v;
+    }).join('_') + '.d.ts';
+}
+function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
     let text = ``;
     if (target < 3.5) {
         text += `
@@ -37,14 +52,15 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 	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;
-	type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =
+	type __VLS_WithComponent<N0 extends string, LocalComponents, Self, 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] } :
+		Self extends object ? { [K in N0]: Self } :
 		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] } :
-		${strictTemplates ? '{}' : '{ [K in N0]: unknown }'};
+		${checkUnknownComponents ? '{}' : '{ [K in N0]: unknown }'};
 	type __VLS_FunctionalComponentProps<T, K> =
 		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
 		: T extends (props: infer P, ...args: any) => any ? P :
@@ -64,7 +80,7 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 				: __VLS_IsFunction<Events, CamelizedEvent> extends true
 					? { [K in onEvent]?: Events[CamelizedEvent] }
 					: Props
-	)${strictTemplates ? '' : ' & Record<string, unknown>'};
+	)${checkUnknownEvents ? '' : ' & Record<string, unknown>'};
 	// 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
@@ -93,25 +109,25 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		'__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_OmitStringIndex<T> = {
+		[K in keyof T as string extends K ? never : K]: T[K];
+	};
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
-	function __VLS_getVForSourceType(source: number): [number, number, number][];
-	function __VLS_getVForSourceType(source: string): [string, number, number][];
+	function __VLS_getVForSourceType(source: number): [number, number][];
+	function __VLS_getVForSourceType(source: string): [string, 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,
+		index: number,
 	][];
 	// #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,
+		index: number,
 	][];
 	function __VLS_getVForSourceType<T>(source: T): [
 		item: T[keyof T],
@@ -138,8 +154,8 @@ function generateGlobalTypes(lib, target, strictTemplates) {
 		} & { props?: ${fnPropsType}; expose?(exposed: K): void; } }
 		: 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>'} } };
-	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
+	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (_: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
 	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
 	function __VLS_tryAsConstant<const T>(t: T): T;

package/lib/codegen/localTypes.d.ts

@@ -6,7 +6,7 @@ export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptio
     readonly PrettifyLocal: string;
     readonly OmitKeepDiscriminatedUnion: string;
     readonly WithDefaults: string;
-    readonly WithTemplateSlots: string;
+    readonly WithSlots: string;
     readonly PropsChildren: string;
     readonly TypePropsToOption: string;
     readonly OmitIndexSignature: string;

package/lib/codegen/localTypes.js

@@ -18,8 +18,8 @@ type __VLS_WithDefaults<P, D> = {
 };
 `.trimStart());
     const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${utils_1.endOfLine}`);
-    const WithTemplateSlots = defineHelper(`__VLS_WithTemplateSlots`, () => `
-type __VLS_WithTemplateSlots<T, S> = T & {
+    const WithSlots = defineHelper(`__VLS_WithSlots`, () => `
+type __VLS_WithSlots<T, S> = T & {
 	new(): {
 		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
 		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
@@ -62,7 +62,7 @@ type __VLS_TypePropsToOption<T> = {
         [PrettifyLocal.name]: PrettifyLocal,
         [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
         [WithDefaults.name]: WithDefaults,
-        [WithTemplateSlots.name]: WithTemplateSlots,
+        [WithSlots.name]: WithSlots,
         [PropsChildren.name]: PropsChildren,
         [TypePropsToOption.name]: TypePropsToOption,
         [OmitIndexSignature.name]: OmitIndexSignature,
@@ -76,7 +76,7 @@ type __VLS_TypePropsToOption<T> = {
         get PrettifyLocal() { return PrettifyLocal.name; },
         get OmitKeepDiscriminatedUnion() { return OmitKeepDiscriminatedUnion.name; },
         get WithDefaults() { return WithDefaults.name; },
-        get WithTemplateSlots() { return WithTemplateSlots.name; },
+        get WithSlots() { return WithSlots.name; },
         get PropsChildren() { return PropsChildren.name; },
         get TypePropsToOption() { return TypePropsToOption.name; },
         get OmitIndexSignature() { return OmitIndexSignature.name; },

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

@@ -0,0 +1,4 @@
+import type { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import type { ScriptCodegenOptions } from './index';
+export declare function generateBindings(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<import("../../types").Code, void, any>;

package/lib/codegen/script/binding.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBindings = generateBindings;
+const utils_1 = require("../utils");
+const component_1 = require("./component");
+const template_1 = require("./template");
+function* generateBindings(options, ctx, templateCodegenCtx) {
+    if (!options.sfc.scriptSetup || !options.scriptSetupRanges) {
+        return;
+    }
+    yield `const __VLS_bindings = {`;
+    if (ctx.bypassDefineComponent) {
+        yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+    }
+    const templateUsageVars = (0, template_1.getTemplateUsageVars)(options, ctx);
+    for (const [content, bindings] of [
+        [options.sfc.scriptSetup.content, options.scriptSetupRanges.bindings],
+        options.sfc.script && options.scriptRanges
+            ? [options.sfc.script.content, options.scriptRanges.bindings]
+            : ['', []],
+    ]) {
+        for (const { range } of bindings) {
+            const varName = content.slice(range.start, range.end);
+            if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessExternalVariables.has(varName)) {
+                continue;
+            }
+            const templateOffset = options.getGeneratedLength();
+            yield `${varName}: ${varName} as typeof `;
+            const scriptOffset = options.getGeneratedLength();
+            yield `${varName},${utils_1.newLine}`;
+            options.linkedCodeMappings.push({
+                sourceOffsets: [scriptOffset],
+                generatedOffsets: [templateOffset],
+                lengths: [varName.length],
+                data: undefined,
+            });
+        }
+    }
+    yield `}${utils_1.endOfLine}`;
+}
+//# sourceMappingURL=binding.js.map

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

@@ -1,7 +1,7 @@
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc } from '../../types';
 import type { ScriptCodegenContext } from './context';
-import { ScriptCodegenOptions } from './index';
+import type { 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 generateEmitsOption(options: ScriptCodegenOptions, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/component.js

@@ -4,12 +4,12 @@ exports.generateComponent = generateComponent;
 exports.generateComponentSetupReturns = generateComponentSetupReturns;
 exports.generateEmitsOption = generateEmitsOption;
 exports.generatePropsOption = generatePropsOption;
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-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, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, index_1.codeFeatures.all);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, codeFeatures_1.codeFeatures.all);
         yield `{${utils_1.newLine}`;
     }
     else {
@@ -34,13 +34,13 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     }
     if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
         const { args } = options.scriptRanges.exportDefault;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, codeFeatures_1.codeFeatures.all);
     }
     if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.templateRefs.size) {
-        yield `__typeRefs: {} as __VLS_TemplateResult['refs'],${utils_1.newLine}`;
+        yield `__typeRefs: {} as __VLS_TemplateRefs,${utils_1.newLine}`;
     }
     if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.singleRootElType) {
-        yield `__typeEl: {} as __VLS_TemplateResult['rootEl'],${utils_1.newLine}`;
+        yield `__typeEl: {} as __VLS_RootEl,${utils_1.newLine}`;
     }
     yield `})`;
 }
@@ -122,12 +122,12 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
     if (scriptSetupRanges.defineProps?.arg) {
         const { arg } = scriptSetupRanges.defineProps;
         codes.push({
-            optionExp: (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation),
+            optionExp: (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.navigation),
             typeOptionExp: undefined,
         });
     }
     if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
-        let attrsType = `__VLS_TemplateResult['attrs']`;
+        let attrsType = `Partial<__VLS_InheritedAttrs>`;
         if (hasEmitsOption) {
             attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
         }

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

@@ -1,5 +1,5 @@
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
 import type { ScriptCodegenContext } from './context';
-import { type ScriptCodegenOptions } from './index';
+import type { ScriptCodegenOptions } from './index';
 export declare function generateComponentSelf(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/script/componentSelf.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateComponentSelf = generateComponentSelf;
 const path = require("path-browserify");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const component_1 = require("./component");
-const index_1 = require("./index");
 const template_1 = require("./template");
 function* generateComponentSelf(options, ctx, templateCodegenCtx) {
     if (options.sfc.scriptSetup && options.scriptSetupRanges) {
@@ -50,7 +50,7 @@ function* generateComponentSelf(options, ctx, templateCodegenCtx) {
         }
         if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
             const { args } = options.scriptRanges.exportDefault;
-            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, codeFeatures_1.codeFeatures.all);
         }
         yield `})${utils_1.endOfLine}`; // defineComponent {
     }

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

@@ -19,7 +19,7 @@ export declare function createScriptCodegenContext(options: ScriptCodegenOptions
         readonly PrettifyLocal: string;
         readonly OmitKeepDiscriminatedUnion: string;
         readonly WithDefaults: string;
-        readonly WithTemplateSlots: string;
+        readonly WithSlots: string;
         readonly PropsChildren: string;
         readonly TypePropsToOption: string;
         readonly OmitIndexSignature: string;

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

@@ -2,16 +2,9 @@ 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 { Code, Sfc, VueCompilerOptions } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
 import { ScriptCodegenContext } from './context';
-export declare const codeFeatures: {
-    all: VueCodeInformation;
-    none: VueCodeInformation;
-    verification: VueCodeInformation;
-    navigation: VueCodeInformation;
-    navigationWithoutRename: VueCodeInformation;
-};
 export interface ScriptCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;