@vue/language-core 1.7.0

package/out/types.d.ts

@@ -0,0 +1,100 @@
+import * as embedded from '@volar/language-core';
+import { SFCParseResult } from '@vue/compiler-sfc';
+import * as CompilerDom from '@vue/compiler-dom';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueEmbeddedFile } from './sourceFile';
+export type { SFCParseResult } from '@vue/compiler-sfc';
+export interface VueLanguageServiceHost extends embedded.LanguageServiceHost {
+    getVueCompilationSettings(): VueCompilerOptions | undefined;
+}
+export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3;
+    plugins?: string[];
+};
+export interface VueCompilerOptions {
+    target: number;
+    lib: string;
+    extensions: string[];
+    jsxSlots: boolean;
+    strictTemplates: boolean;
+    skipTemplateCodegen: boolean;
+    dataAttributes: string[];
+    htmlAttributes: string[];
+    optionsWrapper: [string, string] | [];
+    macros: {
+        defineProps: string[];
+        defineSlots: string[];
+        defineEmits: string[];
+        defineExpose: string[];
+        withDefaults: string[];
+    };
+    plugins: VueLanguagePlugin[];
+    hooks: string[];
+    experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
+    experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
+    experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
+    experimentalUseElementAccessInTemplate: boolean;
+    experimentalAdditionalLanguageModules: string[];
+}
+export type VueLanguagePlugin = (ctx: {
+    modules: {
+        typescript: typeof import('typescript/lib/tsserverlibrary');
+        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+}) => {
+    version: 1;
+    name?: string;
+    order?: number;
+    parseSFC?(fileName: string, content: string): SFCParseResult | undefined;
+    updateSFC?(oldResult: SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDom.CompilerOptions): CompilerDom.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDom.CompilerOptions): CompilerDom.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDom.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDom.CodegenResult | undefined;
+    getEmbeddedFileNames?(fileName: string, sfc: Sfc): string[];
+    resolveEmbeddedFile?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedFile): void;
+};
+export interface SfcBlock {
+    name: string;
+    start: number;
+    end: number;
+    startTagEnd: number;
+    endTagStart: number;
+    lang: string;
+    content: string;
+    attrs: Record<string, string | true>;
+}
+export interface Sfc {
+    template: SfcBlock | null;
+    script: (SfcBlock & {
+        src: string | undefined;
+        srcOffset: number;
+    }) | null;
+    scriptSetup: SfcBlock & {
+        generic: string | undefined;
+        genericOffset: number;
+    } | null;
+    styles: (SfcBlock & {
+        module: string | undefined;
+        scoped: boolean;
+    })[];
+    customBlocks: (SfcBlock & {
+        type: string;
+    })[];
+    templateAst: CompilerDom.RootNode | undefined;
+    scriptAst: ts.SourceFile | undefined;
+    scriptSetupAst: ts.SourceFile | undefined;
+}
+export interface TextRange {
+    start: number;
+    end: number;
+}

package/out/types.js

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

package/out/utils/directorySharedTypes.d.ts

@@ -0,0 +1,6 @@
+import { VueCompilerOptions } from '../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare const baseName = "__VLS_types.d.ts";
+export declare function getImportName(compilerOptions: ts.CompilerOptions): "./__VLS_types" | "./__VLS_types.js";
+export declare function getTypesCode(vueCompilerOptions: VueCompilerOptions): string;
+export declare function genConstructorOverloads(name?: string, nums?: number): string;

package/out/utils/directorySharedTypes.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genConstructorOverloads = exports.getTypesCode = exports.getImportName = exports.baseName = void 0;
+const shared_1 = require("./shared");
+exports.baseName = '__VLS_types.d.ts';
+function getImportName(compilerOptions) {
+    if (!compilerOptions.module || compilerOptions.module === 1) {
+        return './__VLS_types';
+    }
+    return './__VLS_types.js';
+}
+exports.getImportName = getImportName;
+;
+function getTypesCode(vueCompilerOptions) {
+    return `
+// @ts-nocheck
+import type {
+	ObjectDirective,
+	FunctionDirective,
+	VNode,
+} from '${vueCompilerOptions.lib}';
+
+export type IntrinsicElements = PickNotAny<import('vue/jsx-runtime').JSX.IntrinsicElements, PickNotAny<JSX.IntrinsicElements, Record<string, any>>>;
+export type Element = PickNotAny<import('vue/jsx-runtime').JSX.Element, JSX.Element>;
+
+type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+export type PickNotAny<A, B> = IsAny<A> extends true ? B : A;
+
+export type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+
+export type GlobalComponents =
+	// @ts-ignore
+	PickNotAny<import('vue').GlobalComponents, {}>
+	// @ts-ignore
+	& PickNotAny<import('@vue/runtime-core').GlobalComponents, {}>
+	// @ts-ignore
+	& PickNotAny<import('@vue/runtime-dom').GlobalComponents, {}>
+	& Pick<typeof import('${vueCompilerOptions.lib}'),
+		// @ts-ignore
+		'Transition'
+		| 'TransitionGroup'
+		| 'KeepAlive'
+		| 'Suspense'
+		| 'Teleport'
+	>;
+
+// v-for
+export declare function getVForSourceType(source: number): [number, number, number][];
+export declare function getVForSourceType(source: string): [string, number, number][];
+export declare function getVForSourceType<T extends any[]>(source: T): [
+	T[number], // item
+	number, // key
+	number, // index
+][];
+export declare function getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+	T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, // item 
+	number, // key
+	undefined, // index
+][];
+export declare function getVForSourceType<T>(source: T): [
+	T[keyof T], // item
+	keyof T, // key
+	number, // index
+][];
+
+export declare function getSlotParams<T>(slot: T): Parameters<PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+export declare function getSlotParam<T>(slot: T): Parameters<PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+export declare function directiveFunction<T>(dir: T):
+	T extends ObjectDirective<infer E, infer V> | FunctionDirective<infer E, infer V> ? (el: E, value: V) => void
+	: T;
+export declare function withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+export declare function makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+
+export type SelfComponent<N, C> = string extends N ? {} : N extends string ? { [P in N]: C } : {};
+export type WithComponent<N0 extends string, Components, N1 extends string, N2 extends string, N3 extends string> =
+	IsAny<IntrinsicElements[N0]> extends true ? (
+		N1 extends keyof Components ? N1 extends N0 ? Pick<Components, N0> : { [K in N0]: Components[N1] } :
+		N2 extends keyof Components ? N2 extends N0 ? Pick<Components, N0> : { [K in N0]: Components[N2] } :
+		N3 extends keyof Components ? N3 extends N0 ? Pick<Components, N0> : { [K in N0]: Components[N3] } :
+		${vueCompilerOptions.strictTemplates ? '{}' : '{ [K in N0]: any }'}
+	) : Pick<IntrinsicElements, N0>;
+
+export type FillingEventArg_ParametersLength<E extends (...args: any) => any> = IsAny<Parameters<E>> extends true ? -1 : Parameters<E>['length'];
+export type FillingEventArg<E> = E extends (...args: any) => any ? FillingEventArg_ParametersLength<E> extends 0 ? ($event?: undefined) => ReturnType<E> : E : E;
+export type EmitEvent<F, E> =
+	F extends {
+		(event: E, ...payload: infer P): any
+	} ? (...payload: P) => void
+	: F extends {
+		(event: E, ...payload: infer P): any
+		(...args: any): any
+	} ? (...payload: P) => void
+	: F extends {
+		(event: E, ...payload: infer P): any
+		(...args: any): any
+		(...args: any): any
+	} ? (...payload: P) => void
+	: F extends {
+		(event: E, ...payload: infer P): any
+		(...args: any): any
+		(...args: any): any
+		(...args: any): any
+	} ? (...payload: P) => void
+	: unknown | '[Type Warning] Volar could not infer $emit event more than 4 overloads without DefineComponent. see https://github.com/vuejs/language-tools/issues/60';
+export declare function asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+	T extends new (...args: any) => any
+	? (props: (K extends { $props: infer Props } ? Props : any)${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: {
+		attrs?: any,
+		slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: infer Slots } ? Slots : any,
+		emit?: K extends { $emit: infer Emit } ? Emit : any
+	}) => JSX.Element & { __ctx?: typeof ctx & { props?: typeof props; expose?(exposed: K): void; } }
+	: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+	: T extends (...args: any) => any ? T
+	: (_: T extends VNode | VNode[] | string ? {}: T & Record<string, unknown>, ctx?: any) => { __ctx?: { attrs?: unknown, expose?: unknown, slots?: unknown, emit?: unknown, props?: T & Record<string, unknown> } }; // IntrinsicElement
+declare function functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+export declare function pickEvent<Emit, K, E>(emit: Emit, emitKey: K, event: E): FillingEventArg<
+	PickNotAny<
+		AsFunctionOrAny<E>,
+		AsFunctionOrAny<EmitEvent<Emit, K>>
+	>
+>;
+export declare function pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): PickNotAny<
+	K extends { __ctx?: infer Ctx } ? Ctx : any,
+	T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+>;
+type AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
+
+export declare function componentProps<T, K>(comp: T, fnReturn: K):
+	PickNotAny<K, {}> extends { __ctx: { props: infer P } } ? NonNullable<P>
+	: T extends (props: infer P, ...args: any) => any ? NonNullable<P> :
+	{};
+`.trim();
+}
+exports.getTypesCode = getTypesCode;
+// TODO: not working for overloads > n (n = 8)
+// see: https://github.com/vuejs/language-tools/issues/60
+function genConstructorOverloads(name = 'ConstructorOverloads', nums) {
+    let code = '';
+    code += `type ${name}<T> =\n`;
+    if (nums === undefined) {
+        for (let i = 8; i >= 1; i--) {
+            gen(i);
+        }
+    }
+    else if (nums > 0) {
+        gen(nums);
+    }
+    code += `// 0\n`;
+    code += `{};\n`;
+    return code;
+    function gen(i) {
+        code += `// ${i}\n`;
+        code += `T extends {\n`;
+        for (let j = 1; j <= i; j++) {
+            code += `(event: infer E${j}, ...payload: infer P${j}): void;\n`;
+        }
+        code += `} ? (\n`;
+        for (let j = 1; j <= i; j++) {
+            if (j > 1)
+                code += '& ';
+            code += `(E${j} extends string ? { [K${j} in E${j}]: (...payload: P${j}) => void } : {})\n`;
+        }
+        code += `) :\n`;
+    }
+}
+exports.genConstructorOverloads = genConstructorOverloads;
+//# sourceMappingURL=directorySharedTypes.js.map

package/out/utils/parseCssClassNames.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssClassNames(styleContent: string): Generator<{
+    start: number;
+    end: number;
+}, void, unknown>;

package/out/utils/parseCssClassNames.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssClassNames = void 0;
+const parseCssVars_1 = require("./parseCssVars");
+function* parseCssClassNames(styleContent) {
+    styleContent = (0, parseCssVars_1.clearComments)(styleContent);
+    const cssClassNameRegex = /(?=([\.]{1}[a-zA-Z_]+[\w\_\-]*)[\s\.\+\{\>#\:]{1})/g;
+    const matchs = styleContent.matchAll(cssClassNameRegex);
+    for (const match of matchs) {
+        if (match.index !== undefined) {
+            const matchText = match[1];
+            if (matchText !== undefined) {
+                yield { start: match.index, end: match.index + matchText.length };
+            }
+        }
+    }
+}
+exports.parseCssClassNames = parseCssClassNames;
+//# sourceMappingURL=parseCssClassNames.js.map

package/out/utils/parseCssVars.d.ts

@@ -0,0 +1,5 @@
+export declare function parseCssVars(styleContent: string): Generator<{
+    start: number;
+    end: number;
+}, void, unknown>;
+export declare function clearComments(css: string): string;

package/out/utils/parseCssVars.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearComments = exports.parseCssVars = void 0;
+// https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/cssVars.ts#L47-L61
+function* parseCssVars(styleContent) {
+    styleContent = clearComments(styleContent);
+    const reg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([^'"][^)]*))\s*\)/g;
+    const matchs = styleContent.matchAll(reg);
+    for (const match of matchs) {
+        if (match.index !== undefined) {
+            const matchText = match[1] ?? match[2] ?? match[3];
+            if (matchText !== undefined) {
+                const offset = match.index + styleContent.slice(match.index).indexOf(matchText);
+                yield { start: offset, end: offset + matchText.length };
+            }
+        }
+    }
+}
+exports.parseCssVars = parseCssVars;
+function clearComments(css) {
+    return css
+        .replace(/\/\*([\s\S]*?)\*\//g, match => `/*${' '.repeat(match.length - 4)}*/`)
+        .replace(/\/\/([\s\S]*?)\n/g, match => `//${' '.repeat(match.length - 3)}\n`);
+}
+exports.clearComments = clearComments;
+//# sourceMappingURL=parseCssVars.js.map

package/out/utils/parseSfc.d.ts

@@ -0,0 +1,2 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+export declare function parse(source: string): SFCParseResult;

package/out/utils/parseSfc.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const compiler = require("@vue/compiler-dom");
+function parse(source) {
+    const errors = [];
+    const ast = compiler.parse(source, {
+        // there are no components at SFC parsing level
+        isNativeTag: () => true,
+        // preserve all whitespaces
+        isPreTag: () => true,
+        getTextMode: ({ tag, props }, parent) => {
+            if ((!parent && tag !== 'template')
+                || (tag === 'template'
+                    && props.some(p => p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */ &&
+                        p.name === 'lang' &&
+                        p.value &&
+                        p.value.content &&
+                        p.value.content !== 'html'))) {
+                return 2 /* compiler.TextModes.RAWTEXT */;
+            }
+            else {
+                return 0 /* compiler.TextModes.DATA */;
+            }
+        },
+        onError: e => {
+            errors.push(e);
+        },
+        comments: true,
+    });
+    const descriptor = {
+        filename: 'anonymous.vue',
+        source,
+        template: null,
+        script: null,
+        scriptSetup: null,
+        styles: [],
+        customBlocks: [],
+        cssVars: [],
+        slotted: false,
+        shouldForceReload: () => false,
+    };
+    ast.children.forEach(node => {
+        if (node.type !== 1 /* compiler.NodeTypes.ELEMENT */) {
+            return;
+        }
+        switch (node.tag) {
+            case 'template':
+                const templateBlock = (descriptor.template = createBlock(node, source));
+                templateBlock.ast = node;
+                break;
+            case 'script':
+                const scriptBlock = createBlock(node, source);
+                const isSetup = !!scriptBlock.attrs.setup;
+                if (isSetup && !descriptor.scriptSetup) {
+                    descriptor.scriptSetup = scriptBlock;
+                    break;
+                }
+                if (!isSetup && !descriptor.script) {
+                    descriptor.script = scriptBlock;
+                    break;
+                }
+                break;
+            case 'style':
+                const styleBlock = createBlock(node, source);
+                descriptor.styles.push(styleBlock);
+                break;
+            default:
+                descriptor.customBlocks.push(createBlock(node, source));
+                break;
+        }
+    });
+    return {
+        descriptor,
+        errors,
+    };
+}
+exports.parse = parse;
+function createBlock(node, source) {
+    const type = node.tag;
+    let { start, end } = node.loc;
+    let content = '';
+    if (node.children.length) {
+        start = node.children[0].loc.start;
+        end = node.children[node.children.length - 1].loc.end;
+        content = source.slice(start.offset, end.offset);
+    }
+    else {
+        const offset = node.loc.source.indexOf(`</`);
+        if (offset > -1) {
+            start = {
+                line: start.line,
+                column: start.column + offset,
+                offset: start.offset + offset
+            };
+        }
+        end = Object.assign({}, start);
+    }
+    const loc = {
+        source: content,
+        start,
+        end
+    };
+    const attrs = {};
+    const block = {
+        type,
+        content,
+        loc,
+        attrs
+    };
+    node.props.forEach(p => {
+        if (p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */) {
+            attrs[p.name] = p.value ? p.value.content || true : true;
+            if (p.name === 'lang') {
+                block.lang = p.value && p.value.content;
+            }
+            else if (p.name === 'src') {
+                block.src = p.value && p.value.content;
+            }
+            else if (type === 'style') {
+                if (p.name === 'scoped') {
+                    block.scoped = true;
+                }
+                else if (p.name === 'module') {
+                    block.module = attrs[p.name];
+                }
+            }
+            else if (type === 'script' && p.name === 'setup') {
+                block.setup = attrs.setup;
+            }
+        }
+    });
+    return block;
+}
+//# sourceMappingURL=parseSfc.js.map

package/out/utils/shared.d.ts

@@ -0,0 +1 @@
+export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";

package/out/utils/shared.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSlotsPropertyName = void 0;
+function getSlotsPropertyName(vueVersion) {
+    return vueVersion < 3 ? '$scopedSlots' : '$slots';
+}
+exports.getSlotsPropertyName = getSlotsPropertyName;
+//# sourceMappingURL=shared.js.map

package/out/utils/transform.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueCompilerOptions } from '../types';
+export declare function walkInterpolationFragment(ts: typeof import('typescript/lib/tsserverlibrary'), code: string, ast: ts.SourceFile, cb: (fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean) => void, localVars: Record<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions): {
+    text: string;
+    isShorthand: boolean;
+    offset: number;
+}[];
+export declare function colletVars(ts: typeof import('typescript/lib/tsserverlibrary'), node: ts.Node, result: string[]): void;