@vue/language-service 1.7.0

package/out/helpers.d.ts

@@ -0,0 +1,15 @@
+import * as embedded from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function checkPropsOfTag(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, tag: string, nativeTags: Set<string>, requiredOnly?: boolean): string[];
+export declare function checkEventsOfTag(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, tag: string, nativeTags: Set<string>): string[];
+export declare function checkComponentNames(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, nativeTags: Set<string>): string[];
+export declare function checkNativeTags(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, fileName: string): Set<string>;
+export declare function getElementAttrs(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, fileName: string, tagName: string): string[];
+type Tags = Map<string, {
+    offsets: number[];
+    attrs: Map<string, {
+        offsets: number[];
+    }>;
+}>;
+export declare function getTemplateTagsAndAttrs(sourceFile: embedded.VirtualFile): Tags;
+export {};

package/out/helpers.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateTagsAndAttrs = exports.getElementAttrs = exports.checkNativeTags = exports.checkComponentNames = exports.checkEventsOfTag = exports.checkPropsOfTag = void 0;
+const vue = require("@vue/language-core");
+const embedded = require("@volar/language-core");
+const reactivity_1 = require("@vue/reactivity");
+const language_core_1 = require("@vue/language-core");
+const shared_1 = require("@vue/shared");
+function checkPropsOfTag(ts, tsLs, sourceFile, tag, nativeTags, requiredOnly = false) {
+    const checker = tsLs.getProgram().getTypeChecker();
+    const components = getComponentsType(ts, tsLs, sourceFile);
+    if (!components)
+        return [];
+    const name = tag.split('.');
+    let componentSymbol = components.componentsType.getProperty(name[0]);
+    if (!componentSymbol && !nativeTags.has(name[0])) {
+        componentSymbol = components.componentsType.getProperty((0, shared_1.camelize)(name[0]))
+            ?? components.componentsType.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
+    }
+    if (!componentSymbol)
+        return [];
+    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.componentsNode);
+    for (let i = 1; i < name.length; i++) {
+        componentSymbol = componentType.getProperty(name[i]);
+        if (componentSymbol) {
+            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.componentsNode);
+        }
+        else {
+            return [];
+        }
+    }
+    const result = new Set();
+    for (const sig of componentType.getCallSignatures()) {
+        const propParam = sig.parameters[0];
+        if (propParam) {
+            const propsType = checker.getTypeOfSymbolAtLocation(propParam, components.componentsNode);
+            const props = propsType.getProperties();
+            for (const prop of props) {
+                if (!requiredOnly || !(prop.flags & ts.SymbolFlags.Optional)) {
+                    result.add(prop.name);
+                }
+            }
+        }
+    }
+    for (const sig of componentType.getConstructSignatures()) {
+        const instanceType = sig.getReturnType();
+        const propsSymbol = instanceType.getProperty('$props');
+        if (propsSymbol) {
+            const propsType = checker.getTypeOfSymbolAtLocation(propsSymbol, components.componentsNode);
+            const props = propsType.getProperties();
+            for (const prop of props) {
+                if (prop.flags & ts.SymbolFlags.Method) { // #2443
+                    continue;
+                }
+                if (!requiredOnly || !(prop.flags & ts.SymbolFlags.Optional)) {
+                    result.add(prop.name);
+                }
+            }
+        }
+    }
+    return [...result];
+}
+exports.checkPropsOfTag = checkPropsOfTag;
+function checkEventsOfTag(ts, tsLs, sourceFile, tag, nativeTags) {
+    const checker = tsLs.getProgram().getTypeChecker();
+    const components = getComponentsType(ts, tsLs, sourceFile);
+    if (!components)
+        return [];
+    const name = tag.split('.');
+    let componentSymbol = components.componentsType.getProperty(name[0]);
+    if (!componentSymbol && !nativeTags.has(name[0])) {
+        componentSymbol = components.componentsType.getProperty((0, shared_1.camelize)(name[0]))
+            ?? components.componentsType.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
+    }
+    if (!componentSymbol)
+        return [];
+    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.componentsNode);
+    for (let i = 1; i < name.length; i++) {
+        componentSymbol = componentType.getProperty(name[i]);
+        if (componentSymbol) {
+            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.componentsNode);
+        }
+        else {
+            return [];
+        }
+    }
+    const result = new Set();
+    // for (const sig of componentType.getCallSignatures()) {
+    // 	const emitParam = sig.parameters[1];
+    // 	if (emitParam) {
+    // 		// TODO
+    // 	}
+    // }
+    for (const sig of componentType.getConstructSignatures()) {
+        const instanceType = sig.getReturnType();
+        const emitSymbol = instanceType.getProperty('$emit');
+        if (emitSymbol) {
+            const emitType = checker.getTypeOfSymbolAtLocation(emitSymbol, components.componentsNode);
+            for (const call of emitType.getCallSignatures()) {
+                const eventNameParamSymbol = call.parameters[0];
+                if (eventNameParamSymbol) {
+                    const eventNameParamType = checker.getTypeOfSymbolAtLocation(eventNameParamSymbol, components.componentsNode);
+                    if (eventNameParamType.isStringLiteral()) {
+                        result.add(eventNameParamType.value);
+                    }
+                }
+            }
+        }
+    }
+    return [...result];
+}
+exports.checkEventsOfTag = checkEventsOfTag;
+function checkComponentNames(ts, tsLs, sourceFile, nativeTags) {
+    return getComponentsType(ts, tsLs, sourceFile)
+        ?.componentsType
+        ?.getProperties()
+        .map(c => c.name)
+        .filter(entry => entry.indexOf('$') === -1 && !entry.startsWith('_'))
+        .filter(entry => !nativeTags.has(entry))
+        ?? [];
+}
+exports.checkComponentNames = checkComponentNames;
+function checkNativeTags(ts, tsLs, fileName) {
+    const sharedTypesFileName = fileName.substring(0, fileName.lastIndexOf('/')) + '/' + language_core_1.sharedTypes.baseName;
+    const result = new Set();
+    let tsSourceFile;
+    if (tsSourceFile = tsLs.getProgram()?.getSourceFile(sharedTypesFileName)) {
+        const typeNode = tsSourceFile.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.getText() === 'IntrinsicElements');
+        const checker = tsLs.getProgram()?.getTypeChecker();
+        if (checker && typeNode) {
+            const type = checker.getTypeFromTypeNode(typeNode.type);
+            const props = type.getProperties();
+            for (const prop of props) {
+                result.add(prop.name);
+            }
+        }
+    }
+    return result;
+}
+exports.checkNativeTags = checkNativeTags;
+function getElementAttrs(ts, tsLs, fileName, tagName) {
+    const sharedTypesFileName = fileName.substring(0, fileName.lastIndexOf('/')) + '/' + language_core_1.sharedTypes.baseName;
+    let tsSourceFile;
+    if (tsSourceFile = tsLs.getProgram()?.getSourceFile(sharedTypesFileName)) {
+        const typeNode = tsSourceFile.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.getText() === 'IntrinsicElements');
+        const checker = tsLs.getProgram()?.getTypeChecker();
+        if (checker && typeNode) {
+            const type = checker.getTypeFromTypeNode(typeNode.type);
+            const el = type.getProperty(tagName);
+            if (el) {
+                const attrs = checker.getTypeOfSymbolAtLocation(el, typeNode).getProperties();
+                return attrs.map(c => c.name);
+            }
+        }
+    }
+    return [];
+}
+exports.getElementAttrs = getElementAttrs;
+function getComponentsType(ts, tsLs, sourceFile) {
+    if (!(sourceFile instanceof vue.VueFile)) {
+        return;
+    }
+    let file;
+    let tsSourceFile;
+    embedded.forEachEmbeddedFile(sourceFile, embedded => {
+        if (embedded.fileName === sourceFile.mainScriptName) {
+            file = embedded;
+        }
+    });
+    if (file && (tsSourceFile = tsLs.getProgram()?.getSourceFile(file.fileName))) {
+        const componentsNode = getComponentsNode(ts, tsSourceFile);
+        const checker = tsLs.getProgram()?.getTypeChecker();
+        if (checker && componentsNode) {
+            return {
+                componentsNode,
+                componentsType: checker.getTypeAtLocation(componentsNode),
+            };
+        }
+    }
+    function getComponentsNode(ts, sourceFile) {
+        let componentsNode;
+        walk(sourceFile);
+        return componentsNode;
+        function walk(node) {
+            if (componentsNode) {
+                return;
+            }
+            else if (ts.isVariableDeclaration(node) && node.name.getText() === '__VLS_components') {
+                componentsNode = node;
+            }
+            else {
+                node.forEachChild(walk);
+            }
+        }
+    }
+}
+const map = new WeakMap();
+function getTemplateTagsAndAttrs(sourceFile) {
+    if (!map.has(sourceFile)) {
+        const getter = (0, reactivity_1.computed)(() => {
+            if (!(sourceFile instanceof vue.VueFile))
+                return;
+            const ast = sourceFile.compiledSFCTemplate?.ast;
+            const tags = new Map();
+            if (ast) {
+                vue.walkElementNodes(ast, node => {
+                    if (!tags.has(node.tag)) {
+                        tags.set(node.tag, { offsets: [], attrs: new Map() });
+                    }
+                    const tag = tags.get(node.tag);
+                    const startTagHtmlOffset = node.loc.start.offset + node.loc.source.indexOf(node.tag);
+                    const endTagHtmlOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
+                    tag.offsets.push(startTagHtmlOffset);
+                    if (!node.isSelfClosing) {
+                        tag.offsets.push(endTagHtmlOffset);
+                    }
+                    for (const prop of node.props) {
+                        let name;
+                        let offset;
+                        if (prop.type === 7 /* CompilerDOM.NodeTypes.DIRECTIVE */
+                            && prop.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */
+                            && prop.arg.isStatic) {
+                            name = prop.arg.content;
+                            offset = prop.arg.loc.start.offset;
+                        }
+                        else if (prop.type === 6 /* CompilerDOM.NodeTypes.ATTRIBUTE */) {
+                            name = prop.name;
+                            offset = prop.loc.start.offset;
+                        }
+                        if (name !== undefined && offset !== undefined) {
+                            if (!tag.attrs.has(name)) {
+                                tag.attrs.set(name, { offsets: [] });
+                            }
+                            tag.attrs.get(name).offsets.push(offset);
+                        }
+                    }
+                });
+            }
+            return tags;
+        });
+        map.set(sourceFile, getter);
+    }
+    return map.get(sourceFile).value ?? new Map();
+}
+exports.getTemplateTagsAndAttrs = getTemplateTagsAndAttrs;
+//# sourceMappingURL=helpers.js.map

package/out/ideFeatures/nameCasing.d.ts

@@ -0,0 +1,13 @@
+import { ServiceContext } from '@volar/language-service';
+import * as vscode from 'vscode-languageserver-protocol';
+import { AttrNameCasing, TagNameCasing } from '../types';
+export declare function convertTagName(ts: typeof import('typescript/lib/tsserverlibrary'), context: ServiceContext, uri: string, casing: TagNameCasing): Promise<vscode.TextEdit[] | undefined>;
+export declare function convertAttrName(ts: typeof import('typescript/lib/tsserverlibrary'), context: ServiceContext, uri: string, casing: AttrNameCasing): Promise<vscode.TextEdit[] | undefined>;
+export declare function getNameCasing(ts: typeof import('typescript/lib/tsserverlibrary'), context: ServiceContext, uri: string): Promise<{
+    tag: TagNameCasing;
+    attr: AttrNameCasing;
+}>;
+export declare function detect(ts: typeof import('typescript/lib/tsserverlibrary'), context: ServiceContext, uri: string): {
+    tag: TagNameCasing[];
+    attr: AttrNameCasing[];
+};

package/out/ideFeatures/nameCasing.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = exports.getNameCasing = exports.convertAttrName = exports.convertTagName = void 0;
+const shared_1 = require("@vue/shared");
+const helpers_1 = require("../helpers");
+const vue = require("@vue/language-core");
+const vscode = require("vscode-languageserver-protocol");
+const types_1 = require("../types");
+async function convertTagName(ts, context, uri, casing) {
+    if (!context.typescript)
+        return;
+    const rootFile = context.documents.getSourceByUri(uri)?.root;
+    if (!(rootFile instanceof vue.VueFile))
+        return;
+    const desc = rootFile.sfc;
+    if (!desc.template)
+        return;
+    const template = desc.template;
+    const document = context.documents.getDocumentByFileName(rootFile.snapshot, rootFile.fileName);
+    const edits = [];
+    const nativeTags = (0, helpers_1.checkNativeTags)(ts, context.typescript.languageService, rootFile.fileName);
+    const components = (0, helpers_1.checkComponentNames)(ts, context.typescript.languageService, rootFile, nativeTags);
+    const tags = (0, helpers_1.getTemplateTagsAndAttrs)(rootFile);
+    for (const [tagName, { offsets }] of tags) {
+        const componentName = components.find(component => component === tagName || (0, shared_1.hyphenate)(component) === tagName);
+        if (componentName) {
+            for (const offset of offsets) {
+                const start = document.positionAt(template.startTagEnd + offset);
+                const end = document.positionAt(template.startTagEnd + offset + tagName.length);
+                const range = vscode.Range.create(start, end);
+                if (casing === types_1.TagNameCasing.Kebab && tagName !== (0, shared_1.hyphenate)(componentName)) {
+                    edits.push(vscode.TextEdit.replace(range, (0, shared_1.hyphenate)(componentName)));
+                }
+                if (casing === types_1.TagNameCasing.Pascal && tagName !== componentName) {
+                    edits.push(vscode.TextEdit.replace(range, componentName));
+                }
+            }
+        }
+    }
+    return edits;
+}
+exports.convertTagName = convertTagName;
+async function convertAttrName(ts, context, uri, casing) {
+    if (!context.typescript)
+        return;
+    const rootFile = context.documents.getSourceByUri(uri)?.root;
+    if (!(rootFile instanceof vue.VueFile))
+        return;
+    const desc = rootFile.sfc;
+    if (!desc.template)
+        return;
+    const template = desc.template;
+    const document = context.documents.getDocumentByFileName(rootFile.snapshot, rootFile.fileName);
+    const edits = [];
+    const nativeTags = (0, helpers_1.checkNativeTags)(ts, context.typescript.languageService, rootFile.fileName);
+    const components = (0, helpers_1.checkComponentNames)(ts, context.typescript.languageService, rootFile, nativeTags);
+    const tags = (0, helpers_1.getTemplateTagsAndAttrs)(rootFile);
+    for (const [tagName, { attrs }] of tags) {
+        const componentName = components.find(component => component === tagName || (0, shared_1.hyphenate)(component) === tagName);
+        if (componentName) {
+            const props = (0, helpers_1.checkPropsOfTag)(ts, context.typescript.languageService, rootFile, componentName, nativeTags);
+            for (const [attrName, { offsets }] of attrs) {
+                const propName = props.find(prop => prop === attrName || (0, shared_1.hyphenate)(prop) === attrName);
+                if (propName) {
+                    for (const offset of offsets) {
+                        const start = document.positionAt(template.startTagEnd + offset);
+                        const end = document.positionAt(template.startTagEnd + offset + attrName.length);
+                        const range = vscode.Range.create(start, end);
+                        if (casing === types_1.AttrNameCasing.Kebab && attrName !== (0, shared_1.hyphenate)(propName)) {
+                            edits.push(vscode.TextEdit.replace(range, (0, shared_1.hyphenate)(propName)));
+                        }
+                        if (casing === types_1.AttrNameCasing.Camel && attrName !== propName) {
+                            edits.push(vscode.TextEdit.replace(range, propName));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return edits;
+}
+exports.convertAttrName = convertAttrName;
+async function getNameCasing(ts, context, uri) {
+    const detected = detect(ts, context, uri);
+    const [attr, tag] = await Promise.all([
+        context.env.getConfiguration?.('vue.complete.casing.props', uri),
+        context.env.getConfiguration?.('vue.complete.casing.tags', uri),
+    ]);
+    const tagNameCasing = detected.tag.length === 1 && (tag === 'autoPascal' || tag === 'autoKebab') ? detected.tag[0] : (tag === 'autoKebab' || tag === 'kebab') ? types_1.TagNameCasing.Kebab : types_1.TagNameCasing.Pascal;
+    const attrNameCasing = detected.attr.length === 1 && (attr === 'autoCamel' || attr === 'autoKebab') ? detected.attr[0] : (attr === 'autoCamel' || attr === 'camel') ? types_1.AttrNameCasing.Camel : types_1.AttrNameCasing.Kebab;
+    return {
+        tag: tagNameCasing,
+        attr: attrNameCasing,
+    };
+}
+exports.getNameCasing = getNameCasing;
+function detect(ts, context, uri) {
+    if (!context.typescript) {
+        return {
+            tag: [],
+            attr: [],
+        };
+    }
+    const rootFile = context.documents.getSourceByUri(uri)?.root;
+    if (!(rootFile instanceof vue.VueFile)) {
+        return {
+            tag: [],
+            attr: [],
+        };
+    }
+    return {
+        tag: getTagNameCase(rootFile),
+        attr: getAttrNameCase(rootFile),
+    };
+    function getAttrNameCase(file) {
+        const tags = (0, helpers_1.getTemplateTagsAndAttrs)(file);
+        const result = [];
+        for (const [_, { attrs }] of tags) {
+            for (const [tagName] of attrs) {
+                // attrName
+                if (tagName !== (0, shared_1.hyphenate)(tagName)) {
+                    result.push(types_1.AttrNameCasing.Camel);
+                    break;
+                }
+            }
+            for (const [tagName] of attrs) {
+                // attr-name
+                if (tagName.indexOf('-') >= 0) {
+                    result.push(types_1.AttrNameCasing.Kebab);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    function getTagNameCase(file) {
+        if (!context.typescript) {
+            return [];
+        }
+        const nativeTags = (0, helpers_1.checkNativeTags)(ts, context.typescript.languageService, file.fileName);
+        const components = (0, helpers_1.checkComponentNames)(ts, context.typescript.languageService, file, nativeTags);
+        const tagNames = (0, helpers_1.getTemplateTagsAndAttrs)(file);
+        const result = [];
+        let anyComponentUsed = false;
+        for (const component of components) {
+            if (tagNames.has(component) || tagNames.has((0, shared_1.hyphenate)(component))) {
+                anyComponentUsed = true;
+                break;
+            }
+        }
+        if (!anyComponentUsed) {
+            return []; // not sure component style, because do not have any component using in <template> for check
+        }
+        for (const [tagName] of tagNames) {
+            // TagName
+            if (tagName !== (0, shared_1.hyphenate)(tagName)) {
+                result.push(types_1.TagNameCasing.Pascal);
+                break;
+            }
+        }
+        for (const component of components) {
+            // Tagname -> tagname
+            // TagName -> tag-name
+            if (component !== (0, shared_1.hyphenate)(component) && tagNames.has((0, shared_1.hyphenate)(component))) {
+                result.push(types_1.TagNameCasing.Kebab);
+                break;
+            }
+        }
+        return result;
+    }
+}
+exports.detect = detect;
+//# sourceMappingURL=nameCasing.js.map

package/out/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@volar/language-service';
+export * from './ideFeatures/nameCasing';
+export * from './languageService';
+export * from './types';
+export { injectionKeys } from './plugins/vue';

package/out/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.injectionKeys = void 0;
+__exportStar(require("@volar/language-service"), exports);
+__exportStar(require("./ideFeatures/nameCasing"), exports);
+__exportStar(require("./languageService"), exports);
+__exportStar(require("./types"), exports);
+var vue_1 = require("./plugins/vue");
+Object.defineProperty(exports, "injectionKeys", { enumerable: true, get: function () { return vue_1.injectionKeys; } });
+//# sourceMappingURL=index.js.map

package/out/languageService.d.ts

@@ -0,0 +1,9 @@
+import createJsonPlugin from 'volar-service-json';
+import * as vue from '@vue/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { Config } from '@volar/language-service';
+export interface Settings {
+    json?: Parameters<typeof createJsonPlugin>[0];
+}
+export declare function resolveConfig(config: Config, // volar.config.js
+compilerOptions?: ts.CompilerOptions, vueCompilerOptions?: vue.VueCompilerOptions, settings?: Settings, ts?: typeof import('typescript/lib/tsserverlibrary')): Config;