@vue/typescript-plugin 2.0.0 → 2.0.2

package/index.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript';
+declare const _default: ts.server.PluginModuleFactory;
+export = _default;

package/index.js

@@ -0,0 +1,196 @@
+"use strict";
+const decorateLanguageService_1 = require("@volar/typescript/lib/node/decorateLanguageService");
+const decorateLanguageServiceHost_1 = require("@volar/typescript/lib/node/decorateLanguageServiceHost");
+const language_core_1 = require("@vue/language-core");
+const utils_1 = require("./lib/utils");
+const vue = require("@vue/language-core");
+const server_1 = require("./lib/server");
+const componentInfos_1 = require("./lib/requests/componentInfos");
+const shared_1 = require("@vue/shared");
+const windowsPathReg = /\\/g;
+const externalFiles = new WeakMap();
+const projectExternalFileExtensions = new WeakMap();
+const decoratedLanguageServices = new WeakSet();
+const decoratedLanguageServiceHosts = new WeakSet();
+function createLanguageServicePlugin() {
+    return modules => {
+        const { typescript: ts } = modules;
+        const pluginModule = {
+            create(info) {
+                if (!decoratedLanguageServices.has(info.languageService)
+                    && !decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
+                    decoratedLanguageServices.add(info.languageService);
+                    decoratedLanguageServiceHosts.add(info.languageServiceHost);
+                    const vueOptions = vue.resolveVueCompilerOptions(getVueCompilerOptions());
+                    const languagePlugin = vue.createVueLanguagePlugin(ts, id => id, info.languageServiceHost.getCompilationSettings(), vueOptions);
+                    const extensions = languagePlugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [];
+                    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
+                    const files = (0, language_core_1.createFileRegistry)([languagePlugin], ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const snapshot = getScriptSnapshot(fileName);
+                        if (snapshot) {
+                            files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                        }
+                        else {
+                            files.delete(fileName);
+                        }
+                    });
+                    projectExternalFileExtensions.set(info.project, extensions);
+                    utils_1.projects.set(info.project, {
+                        info,
+                        files,
+                        ts,
+                        vueOptions,
+                    });
+                    (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts);
+                    (0, server_1.startNamedPipeServer)(info.project.projectKind);
+                    const getCompletionsAtPosition = info.languageService.getCompletionsAtPosition;
+                    const getCompletionEntryDetails = info.languageService.getCompletionEntryDetails;
+                    const getCodeFixesAtPosition = info.languageService.getCodeFixesAtPosition;
+                    const getEncodedSemanticClassifications = info.languageService.getEncodedSemanticClassifications;
+                    info.languageService.getCompletionsAtPosition = (fileName, position, options) => {
+                        const result = getCompletionsAtPosition(fileName, position, options);
+                        if (result) {
+                            // filter __VLS_
+                            result.entries = result.entries.filter(entry => entry.name.indexOf('__VLS_') === -1
+                                && (!entry.labelDetails?.description || entry.labelDetails.description.indexOf('__VLS_') === -1));
+                            // modify label
+                            for (const item of result.entries) {
+                                if (item.source) {
+                                    const originalName = item.name;
+                                    for (const ext of vueOptions.extensions) {
+                                        const suffix = (0, shared_1.capitalize)(ext.substring('.'.length)); // .vue -> Vue
+                                        if (item.source.endsWith(ext) && item.name.endsWith(suffix)) {
+                                            item.name = item.name.slice(0, -suffix.length);
+                                            if (item.insertText) {
+                                                // #2286
+                                                item.insertText = item.insertText.replace(`${suffix}$1`, '$1');
+                                            }
+                                            if (item.data) {
+                                                // @ts-expect-error
+                                                item.data.__isComponentAutoImport = {
+                                                    ext,
+                                                    suffix,
+                                                    originalName,
+                                                    newName: item.insertText,
+                                                };
+                                            }
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return result;
+                    };
+                    info.languageService.getCompletionEntryDetails = (...args) => {
+                        const details = getCompletionEntryDetails(...args);
+                        // modify import statement
+                        // @ts-expect-error
+                        if (args[6]?.__isComponentAutoImport) {
+                            // @ts-expect-error
+                            const { ext, suffix, originalName, newName } = args[6]?.__isComponentAutoImport;
+                            for (const codeAction of details?.codeActions ?? []) {
+                                for (const change of codeAction.changes) {
+                                    for (const textChange of change.textChanges) {
+                                        textChange.newText = textChange.newText.replace('import ' + originalName + ' from ', 'import ' + newName + ' from ');
+                                    }
+                                }
+                            }
+                        }
+                        return details;
+                    };
+                    info.languageService.getCodeFixesAtPosition = (...args) => {
+                        let result = getCodeFixesAtPosition(...args);
+                        // filter __VLS_
+                        result = result.filter(entry => entry.description.indexOf('__VLS_') === -1);
+                        return result;
+                    };
+                    info.languageService.getEncodedSemanticClassifications = (fileName, span, format) => {
+                        const result = getEncodedSemanticClassifications(fileName, span, format);
+                        const file = files.get(fileName);
+                        if (file?.generated?.code instanceof vue.VueGeneratedCode
+                            && file.generated.code.sfc.template) {
+                            const validComponentNames = (0, componentInfos_1._getComponentNames)(ts, info.languageService, file.generated.code, vueOptions);
+                            const components = new Set([
+                                ...validComponentNames,
+                                ...validComponentNames.map(vue.hyphenateTag),
+                            ]);
+                            const { template } = file.generated.code.sfc;
+                            const spanTemplateRange = [
+                                span.start - template.startTagEnd,
+                                span.start + span.length - template.startTagEnd,
+                            ];
+                            template.ast?.children.forEach(function visit(node) {
+                                if (node.loc.end.offset <= spanTemplateRange[0] || node.loc.start.offset >= spanTemplateRange[1]) {
+                                    return;
+                                }
+                                if (node.type === 1) {
+                                    if (components.has(node.tag)) {
+                                        result.spans.push(node.loc.start.offset + node.loc.source.indexOf(node.tag) + template.startTagEnd, node.tag.length, 256);
+                                        if (template.lang === 'html' && !node.isSelfClosing) {
+                                            result.spans.push(node.loc.start.offset + node.loc.source.lastIndexOf(node.tag) + template.startTagEnd, node.tag.length, 256);
+                                        }
+                                    }
+                                    for (const child of node.children) {
+                                        visit(child);
+                                    }
+                                }
+                                else if (node.type === 9) {
+                                    for (const branch of node.branches) {
+                                        for (const child of branch.children) {
+                                            visit(child);
+                                        }
+                                    }
+                                }
+                                else if (node.type === 11) {
+                                    for (const child of node.children) {
+                                        visit(child);
+                                    }
+                                }
+                            });
+                        }
+                        return result;
+                    };
+                }
+                return info.languageService;
+                function getVueCompilerOptions() {
+                    if (info.project.projectKind === ts.server.ProjectKind.Configured) {
+                        const tsconfig = info.project.getProjectName();
+                        return vue.createParsedCommandLine(ts, ts.sys, tsconfig.replace(windowsPathReg, '/')).vueOptions;
+                    }
+                    else {
+                        return vue.createParsedCommandLineByJson(ts, ts.sys, info.languageServiceHost.getCurrentDirectory(), {}).vueOptions;
+                    }
+                }
+            },
+            getExternalFiles(project, updateLevel = 0) {
+                if (updateLevel >= (1)
+                    || !externalFiles.has(project)) {
+                    const oldFiles = externalFiles.get(project);
+                    const newFiles = (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, projectExternalFileExtensions.get(project));
+                    externalFiles.set(project, newFiles);
+                    if (oldFiles && !arrayItemsEqual(oldFiles, newFiles)) {
+                        project.refreshDiagnostics();
+                    }
+                }
+                return externalFiles.get(project);
+            },
+        };
+        return pluginModule;
+    };
+}
+function arrayItemsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    for (const file of b) {
+        if (!set.has(file)) {
+            return false;
+        }
+    }
+    return true;
+}
+module.exports = createLanguageServicePlugin();
+//# sourceMappingURL=index.js.map

package/lib/client.d.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript';
+export declare function collectExtractProps(...args: Parameters<typeof import('./requests/collectExtractProps.js')['collectExtractProps']>): Promise<{
+    name: string;
+    type: string;
+    model: boolean;
+}[] | null | undefined>;
+export declare function getPropertiesAtLocation(...args: Parameters<typeof import('./requests/getPropertiesAtLocation.js')['getPropertiesAtLocation']>): Promise<string[] | null | undefined>;
+export declare function getQuickInfoAtPosition(...args: Parameters<typeof import('./requests/getQuickInfoAtPosition.js')['getQuickInfoAtPosition']>): Promise<ts.QuickInfo | null | undefined>;
+export declare function getComponentProps(...args: Parameters<typeof import('./requests/componentInfos.js')['getComponentProps']>): Promise<string[] | null | undefined>;
+export declare function getComponentEvents(...args: Parameters<typeof import('./requests/componentInfos.js')['getComponentEvents']>): Promise<string[] | null | undefined>;
+export declare function getTemplateContextProps(...args: Parameters<typeof import('./requests/componentInfos.js')['getTemplateContextProps']>): Promise<string[] | null | undefined>;
+export declare function getComponentNames(...args: Parameters<typeof import('./requests/componentInfos.js')['getComponentNames']>): Promise<string[] | null | undefined>;
+export declare function getElementAttrs(...args: Parameters<typeof import('./requests/componentInfos.js')['getElementAttrs']>): Promise<string[] | null | undefined>;

package/lib/client.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementAttrs = exports.getComponentNames = exports.getTemplateContextProps = exports.getComponentEvents = exports.getComponentProps = exports.getQuickInfoAtPosition = exports.getPropertiesAtLocation = exports.collectExtractProps = void 0;
+const net = require("net");
+const fs = require("fs");
+const utils_1 = require("./utils");
+function collectExtractProps(...args) {
+    return sendRequest({
+        type: 'collectExtractProps',
+        args,
+    });
+}
+exports.collectExtractProps = collectExtractProps;
+async function getPropertiesAtLocation(...args) {
+    return await sendRequest({
+        type: 'getPropertiesAtLocation',
+        args,
+    });
+}
+exports.getPropertiesAtLocation = getPropertiesAtLocation;
+function getQuickInfoAtPosition(...args) {
+    return sendRequest({
+        type: 'getQuickInfoAtPosition',
+        args,
+    });
+}
+exports.getQuickInfoAtPosition = getQuickInfoAtPosition;
+// Component Infos
+function getComponentProps(...args) {
+    return sendRequest({
+        type: 'getComponentProps',
+        args,
+    });
+}
+exports.getComponentProps = getComponentProps;
+function getComponentEvents(...args) {
+    return sendRequest({
+        type: 'getComponentEvents',
+        args,
+    });
+}
+exports.getComponentEvents = getComponentEvents;
+function getTemplateContextProps(...args) {
+    return sendRequest({
+        type: 'getTemplateContextProps',
+        args,
+    });
+}
+exports.getTemplateContextProps = getTemplateContextProps;
+function getComponentNames(...args) {
+    return sendRequest({
+        type: 'getComponentNames',
+        args,
+    });
+}
+exports.getComponentNames = getComponentNames;
+function getElementAttrs(...args) {
+    return sendRequest({
+        type: 'getElementAttrs',
+        args,
+    });
+}
+exports.getElementAttrs = getElementAttrs;
+async function sendRequest(request) {
+    const pipeFile = await getPipeFile(request.args[0]);
+    if (!pipeFile) {
+        console.error('[Vue Named Pipe Client] pipeFile not found');
+        return;
+    }
+    return await _sendRequest(request, pipeFile);
+}
+async function getPipeFile(fileName) {
+    if (fs.existsSync(utils_1.pipeTable)) {
+        const table = JSON.parse(fs.readFileSync(utils_1.pipeTable, 'utf8'));
+        const all = Object.values(table);
+        const configuredServers = all
+            .filter(item => item.serverKind === 1)
+            .sort((a, b) => Math.abs(process.pid - a.pid) - Math.abs(process.pid - b.pid));
+        const inferredServers = all
+            .filter(item => item.serverKind === 0)
+            .sort((a, b) => Math.abs(process.pid - a.pid) - Math.abs(process.pid - b.pid));
+        for (const server of configuredServers) {
+            const response = await _sendRequest({ type: 'containsFile', args: [fileName] }, server.pipeFile);
+            if (response) {
+                return server.pipeFile;
+            }
+        }
+        for (const server of inferredServers) {
+            const response = await _sendRequest({ type: 'containsFile', args: [fileName] }, server.pipeFile);
+            if (typeof response === 'boolean') {
+                return server.pipeFile;
+            }
+        }
+    }
+}
+function _sendRequest(request, pipeFile) {
+    return new Promise(resolve => {
+        try {
+            const client = net.connect(pipeFile);
+            client.on('connect', () => {
+                client.write(JSON.stringify(request));
+            });
+            client.on('data', data => {
+                const text = data.toString();
+                resolve(JSON.parse(text));
+                client.end();
+            });
+            client.on('error', err => {
+                console.error('[Vue Named Pipe Client]', err);
+                return resolve(undefined);
+            });
+        }
+        catch (e) {
+            console.error('[Vue Named Pipe Client]', e);
+            return resolve(undefined);
+        }
+    });
+}
+//# sourceMappingURL=client.js.map

package/lib/requests/collectExtractProps.d.ts

@@ -0,0 +1,5 @@
+export declare function collectExtractProps(fileName: string, templateCodeRange: [number, number], isTsPlugin?: boolean): {
+    name: string;
+    type: string;
+    model: boolean;
+}[] | undefined;

package/lib/requests/collectExtractProps.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectExtractProps = void 0;
+const language_core_1 = require("@vue/language-core");
+const utils_1 = require("../utils");
+function collectExtractProps(fileName, templateCodeRange, isTsPlugin = true) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { info, files, ts } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof language_core_1.VueGeneratedCode)) {
+        return;
+    }
+    const result = new Map();
+    const languageService = info.languageService;
+    const program = languageService.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    const sourceFile = program.getSourceFile(fileName);
+    const checker = program.getTypeChecker();
+    const script = volarFile.generated?.languagePlugin.typescript?.getScript(volarFile.generated.code);
+    const maps = script ? [...files.getMaps(script.code).values()] : [];
+    const sfc = volarFile.generated.code.sfc;
+    sourceFile.forEachChild(function visit(node) {
+        if (ts.isPropertyAccessExpression(node)
+            && ts.isIdentifier(node.expression)
+            && node.expression.text === '__VLS_ctx'
+            && ts.isIdentifier(node.name)) {
+            const { name } = node;
+            for (const [_, map] of maps) {
+                const source = map.getSourceOffset(name.getEnd() - (isTsPlugin ? volarFile.snapshot.getLength() : 0));
+                if (source
+                    && source[0] >= sfc.template.startTagEnd + templateCodeRange[0]
+                    && source[0] <= sfc.template.startTagEnd + templateCodeRange[1]
+                    && (0, language_core_1.isSemanticTokensEnabled)(source[1].data)) {
+                    if (!result.has(name.text)) {
+                        const type = checker.getTypeAtLocation(node);
+                        const typeString = checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
+                        result.set(name.text, {
+                            name: name.text,
+                            type: typeString.includes('__VLS_') ? 'any' : typeString,
+                            model: false,
+                        });
+                    }
+                    const isModel = ts.isPostfixUnaryExpression(node.parent) || ts.isBinaryExpression(node.parent);
+                    if (isModel) {
+                        result.get(name.text).model = true;
+                    }
+                    break;
+                }
+            }
+        }
+        node.forEachChild(visit);
+    });
+    return [...result.values()];
+}
+exports.collectExtractProps = collectExtractProps;
+//# sourceMappingURL=collectExtractProps.js.map

package/lib/requests/componentInfos.d.ts

@@ -0,0 +1,8 @@
+import * as vue from '@vue/language-core';
+import type * as ts from 'typescript';
+export declare function getComponentProps(fileName: string, tag: string, requiredOnly?: boolean): string[] | undefined;
+export declare function getComponentEvents(fileName: string, tag: string): string[] | undefined;
+export declare function getTemplateContextProps(fileName: string): string[] | undefined;
+export declare function getComponentNames(fileName: string): string[] | undefined;
+export declare function _getComponentNames(ts: typeof import('typescript'), tsLs: ts.LanguageService, vueCode: vue.VueGeneratedCode, vueOptions: vue.VueCompilerOptions): string[];
+export declare function getElementAttrs(fileName: string, tagName: string): string[] | undefined;

package/lib/requests/componentInfos.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementAttrs = exports._getComponentNames = exports.getComponentNames = exports.getTemplateContextProps = exports.getComponentEvents = exports.getComponentProps = void 0;
+const vue = require("@vue/language-core");
+const shared_1 = require("@vue/shared");
+const utils_1 = require("../utils");
+function getComponentProps(fileName, tag, requiredOnly = false) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { ts, files, vueOptions } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof vue.VueGeneratedCode)) {
+        return;
+    }
+    const vueCode = volarFile.generated.code;
+    const tsLs = match.info.languageService;
+    const program = tsLs.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    const checker = program.getTypeChecker();
+    const components = getVariableType(ts, tsLs, vueCode, '__VLS_components');
+    if (!components)
+        return [];
+    const name = tag.split('.');
+    let componentSymbol = components.type.getProperty(name[0]);
+    if (!componentSymbol && !vueOptions.nativeTags.includes(name[0])) {
+        componentSymbol = components.type.getProperty((0, shared_1.camelize)(name[0]))
+            ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
+    }
+    if (!componentSymbol)
+        return [];
+    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
+    for (let i = 1; i < name.length; i++) {
+        componentSymbol = componentType.getProperty(name[i]);
+        if (componentSymbol) {
+            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
+        }
+        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.node);
+            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.node);
+            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.getComponentProps = getComponentProps;
+function getComponentEvents(fileName, tag) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { ts, files, vueOptions } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof vue.VueGeneratedCode)) {
+        return;
+    }
+    const tsLs = match.info.languageService;
+    const vueCode = volarFile.generated.code;
+    const program = tsLs.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    const checker = program.getTypeChecker();
+    const components = getVariableType(ts, tsLs, vueCode, '__VLS_components');
+    if (!components)
+        return [];
+    const name = tag.split('.');
+    let componentSymbol = components.type.getProperty(name[0]);
+    if (!componentSymbol && !vueOptions.nativeTags.includes(name[0])) {
+        componentSymbol = components.type.getProperty((0, shared_1.camelize)(name[0]))
+            ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
+    }
+    if (!componentSymbol)
+        return [];
+    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
+    for (let i = 1; i < name.length; i++) {
+        componentSymbol = componentType.getProperty(name[i]);
+        if (componentSymbol) {
+            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
+        }
+        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.node);
+            for (const call of emitType.getCallSignatures()) {
+                const eventNameParamSymbol = call.parameters[0];
+                if (eventNameParamSymbol) {
+                    const eventNameParamType = checker.getTypeOfSymbolAtLocation(eventNameParamSymbol, components.node);
+                    if (eventNameParamType.isStringLiteral()) {
+                        result.add(eventNameParamType.value);
+                    }
+                }
+            }
+        }
+    }
+    return [...result];
+}
+exports.getComponentEvents = getComponentEvents;
+function getTemplateContextProps(fileName) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { ts, files } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof vue.VueGeneratedCode)) {
+        return;
+    }
+    const tsLs = match.info.languageService;
+    const vueCode = volarFile.generated.code;
+    return getVariableType(ts, tsLs, vueCode, '__VLS_ctx')
+        ?.type
+        ?.getProperties()
+        .map(c => c.name);
+}
+exports.getTemplateContextProps = getTemplateContextProps;
+function getComponentNames(fileName) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { ts, files, vueOptions } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof vue.VueGeneratedCode)) {
+        return;
+    }
+    const tsLs = match.info.languageService;
+    const vueCode = volarFile.generated.code;
+    return getVariableType(ts, tsLs, vueCode, '__VLS_components')
+        ?.type
+        ?.getProperties()
+        .map(c => c.name)
+        .filter(entry => entry.indexOf('$') === -1 && !entry.startsWith('_'))
+        .filter(entry => !vueOptions.nativeTags.includes(entry))
+        ?? [];
+}
+exports.getComponentNames = getComponentNames;
+function _getComponentNames(ts, tsLs, vueCode, vueOptions) {
+    return getVariableType(ts, tsLs, vueCode, '__VLS_components')
+        ?.type
+        ?.getProperties()
+        .map(c => c.name)
+        .filter(entry => entry.indexOf('$') === -1 && !entry.startsWith('_'))
+        .filter(entry => !vueOptions.nativeTags.includes(entry))
+        ?? [];
+}
+exports._getComponentNames = _getComponentNames;
+function getElementAttrs(fileName, tagName) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { ts, files } = match;
+    const volarFile = files.get(fileName);
+    if (!(volarFile?.generated?.code instanceof vue.VueGeneratedCode)) {
+        return;
+    }
+    const tsLs = match.info.languageService;
+    const program = tsLs.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    let tsSourceFile;
+    if (tsSourceFile = program.getSourceFile(fileName)) {
+        const typeNode = tsSourceFile.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.getText() === '__VLS_IntrinsicElementsCompletion');
+        const checker = program.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 getVariableType(ts, tsLs, vueCode, name) {
+    const program = tsLs.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    let tsSourceFile;
+    if (tsSourceFile = program.getSourceFile(vueCode.fileName)) {
+        const node = searchVariableDeclarationNode(ts, tsSourceFile, name);
+        const checker = program.getTypeChecker();
+        if (checker && node) {
+            return {
+                node: node,
+                type: checker.getTypeAtLocation(node),
+            };
+        }
+    }
+}
+function searchVariableDeclarationNode(ts, sourceFile, name) {
+    let componentsNode;
+    walk(sourceFile);
+    return componentsNode;
+    function walk(node) {
+        if (componentsNode) {
+            return;
+        }
+        else if (ts.isVariableDeclaration(node) && node.name.getText() === name) {
+            componentsNode = node;
+        }
+        else {
+            node.forEachChild(walk);
+        }
+    }
+}
+//# sourceMappingURL=componentInfos.js.map

package/lib/requests/containsFile.d.ts

@@ -0,0 +1 @@
+export declare function containsFile(fileName: string): boolean;

package/lib/requests/containsFile.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsFile = void 0;
+const utils_1 = require("../utils");
+function containsFile(fileName) {
+    return !!(0, utils_1.getProject)(fileName);
+}
+exports.containsFile = containsFile;
+//# sourceMappingURL=containsFile.js.map

package/lib/requests/getPropertiesAtLocation.d.ts

@@ -0,0 +1 @@
+export declare function getPropertiesAtLocation(fileName: string, position: number, isTsPlugin?: boolean): string[] | undefined;

package/lib/requests/getPropertiesAtLocation.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertiesAtLocation = void 0;
+const language_core_1 = require("@vue/language-core");
+const utils_1 = require("../utils");
+function getPropertiesAtLocation(fileName, position, isTsPlugin = true) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { info, files, ts } = match;
+    const languageService = info.languageService;
+    // mapping
+    const file = files.get(fileName);
+    if (file?.generated) {
+        const virtualScript = file.generated.languagePlugin.typescript?.getScript(file.generated.code);
+        if (!virtualScript) {
+            return;
+        }
+        let mapped = false;
+        for (const [_1, [_2, map]] of files.getMaps(virtualScript.code)) {
+            for (const [position2, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isCompletionEnabled)(mapping.data)) {
+                    position = position2;
+                    mapped = true;
+                    break;
+                }
+            }
+            if (mapped) {
+                break;
+            }
+        }
+        if (!mapped) {
+            return;
+        }
+        if (isTsPlugin) {
+            position += file.snapshot.getLength();
+        }
+    }
+    const program = languageService.getCurrentProgram();
+    if (!program) {
+        return;
+    }
+    const sourceFile = program.getSourceFile(fileName);
+    if (!sourceFile) {
+        return;
+    }
+    const node = findPositionIdentifier(sourceFile, sourceFile, position);
+    if (!node) {
+        return;
+    }
+    const checker = program.getTypeChecker();
+    const type = checker.getTypeAtLocation(node);
+    const props = type.getProperties();
+    return props.map(prop => prop.name);
+    function findPositionIdentifier(sourceFile, node, offset) {
+        let result;
+        node.forEachChild(child => {
+            if (!result) {
+                if (child.end === offset && ts.isIdentifier(child)) {
+                    result = child;
+                }
+                else if (child.end >= offset && child.getStart(sourceFile) < offset) {
+                    result = findPositionIdentifier(sourceFile, child, offset);
+                }
+            }
+        });
+        return result;
+    }
+}
+exports.getPropertiesAtLocation = getPropertiesAtLocation;
+//# sourceMappingURL=getPropertiesAtLocation.js.map

package/lib/requests/getQuickInfoAtPosition.d.ts

@@ -0,0 +1 @@
+export declare function getQuickInfoAtPosition(fileName: string, position: number): import("typescript").QuickInfo | undefined;

package/lib/requests/getQuickInfoAtPosition.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuickInfoAtPosition = void 0;
+const utils_1 = require("../utils");
+function getQuickInfoAtPosition(fileName, position) {
+    const match = (0, utils_1.getProject)(fileName);
+    if (!match) {
+        return;
+    }
+    const { info } = match;
+    const languageService = info.languageService;
+    return languageService.getQuickInfoAtPosition(fileName, position);
+}
+exports.getQuickInfoAtPosition = getQuickInfoAtPosition;
+//# sourceMappingURL=getQuickInfoAtPosition.js.map

package/lib/server.d.ts

@@ -0,0 +1,6 @@
+import type * as ts from 'typescript';
+export interface Request {
+    type: 'containsFile' | 'collectExtractProps' | 'getPropertiesAtLocation' | 'getQuickInfoAtPosition' | 'getComponentProps' | 'getComponentEvents' | 'getTemplateContextProps' | 'getComponentNames' | 'getElementAttrs';
+    args: any;
+}
+export declare function startNamedPipeServer(serverKind: ts.server.ProjectKind): void;

package/lib/server.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startNamedPipeServer = void 0;
+const fs = require("fs");
+const net = require("net");
+const collectExtractProps_1 = require("./requests/collectExtractProps");
+const componentInfos_1 = require("./requests/componentInfos");
+const containsFile_1 = require("./requests/containsFile");
+const getPropertiesAtLocation_1 = require("./requests/getPropertiesAtLocation");
+const getQuickInfoAtPosition_1 = require("./requests/getQuickInfoAtPosition");
+const utils_1 = require("./utils");
+let started = false;
+function startNamedPipeServer(serverKind) {
+    if (started)
+        return;
+    started = true;
+    const pipeFile = process.platform === 'win32'
+        ? `\\\\.\\pipe\\vue-tsp-${process.pid}`
+        : `/tmp/vue-tsp-${process.pid}`;
+    const server = net.createServer(connection => {
+        connection.on('data', data => {
+            const text = data.toString();
+            const request = JSON.parse(text);
+            if (request.type === 'containsFile') {
+                const result = containsFile_1.containsFile.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'collectExtractProps') {
+                const result = collectExtractProps_1.collectExtractProps.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getPropertiesAtLocation') {
+                const result = getPropertiesAtLocation_1.getPropertiesAtLocation.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getQuickInfoAtPosition') {
+                const result = getQuickInfoAtPosition_1.getQuickInfoAtPosition.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            // Component Infos
+            else if (request.type === 'getComponentProps') {
+                const result = componentInfos_1.getComponentProps.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getComponentEvents') {
+                const result = componentInfos_1.getComponentEvents.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getTemplateContextProps') {
+                const result = componentInfos_1.getTemplateContextProps.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getComponentNames') {
+                const result = componentInfos_1.getComponentNames.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else if (request.type === 'getElementAttrs') {
+                const result = componentInfos_1.getElementAttrs.apply(null, request.args);
+                connection.write(JSON.stringify(result ?? null));
+            }
+            else {
+                console.warn('[Vue Named Pipe Server] Unknown request type:', request.type);
+                connection.write(JSON.stringify(null));
+            }
+        });
+        connection.on('error', err => console.error('[Vue Named Pipe Server]', err.message));
+    });
+    clearupPipeTable();
+    if (!fs.existsSync(utils_1.pipeTable)) {
+        fs.writeFileSync(utils_1.pipeTable, JSON.stringify({}));
+    }
+    const table = JSON.parse(fs.readFileSync(utils_1.pipeTable, 'utf8'));
+    table[process.pid] = {
+        pid: process.pid,
+        pipeFile,
+        serverKind,
+    };
+    fs.writeFileSync(utils_1.pipeTable, JSON.stringify(table, undefined, 2));
+    try {
+        fs.unlinkSync(pipeFile);
+    }
+    catch { }
+    server.listen(pipeFile);
+}
+exports.startNamedPipeServer = startNamedPipeServer;
+function clearupPipeTable() {
+    if (fs.existsSync(utils_1.pipeTable)) {
+        const table = JSON.parse(fs.readFileSync(utils_1.pipeTable, 'utf8'));
+        for (const pid in table) {
+            const { pipeFile } = table[pid];
+            try {
+                const client = net.connect(pipeFile);
+                client.on('connect', () => {
+                    client.end();
+                });
+                client.on('error', () => {
+                    const table = JSON.parse(fs.readFileSync(utils_1.pipeTable, 'utf8'));
+                    delete table[pid];
+                    fs.writeFileSync(utils_1.pipeTable, JSON.stringify(table, undefined, 2));
+                });
+            }
+            catch { }
+        }
+    }
+}
+//# sourceMappingURL=server.js.map

package/lib/utils.d.ts

@@ -0,0 +1,31 @@
+import type { FileRegistry, VueCompilerOptions } from '@vue/language-core';
+import type * as ts from 'typescript';
+export interface PipeTable {
+    [pid: string]: {
+        pid: number;
+        pipeFile: string;
+        serverKind: ts.server.ProjectKind;
+    };
+}
+export declare const pipeTable: string;
+export declare const projects: Map<ts.server.Project, {
+    info: ts.server.PluginCreateInfo;
+    files: FileRegistry;
+    ts: typeof ts;
+    vueOptions: VueCompilerOptions;
+}>;
+export declare function getProject(fileName: string): {
+    info: ts.server.PluginCreateInfo;
+    files: {
+        languagePlugins: import("@vue/language-core").LanguagePlugin<import("@vue/language-core").VirtualCode>[];
+        set(id: string, languageId: string, snapshot: ts.IScriptSnapshot, plugins?: import("@vue/language-core").LanguagePlugin<import("@vue/language-core").VirtualCode>[] | undefined): import("@vue/language-core").SourceFile;
+        delete(id: string): void;
+        get(id: string): import("@vue/language-core").SourceFile | undefined;
+        getByVirtualCode(virtualCode: import("@vue/language-core").VirtualCode): import("@vue/language-core").SourceFile;
+        getLinkedCodeMap(virtualCode: import("@vue/language-core").VirtualCode): import("@vue/language-core").LinkedCodeMap | undefined;
+        getMaps(virtualCode: import("@vue/language-core").VirtualCode): Map<string, [ts.IScriptSnapshot, import("@vue/language-core").SourceMap<import("@vue/language-core").CodeInformation>]>;
+        getVirtualCode(sourceFileId: string, virtualCodeId: string): readonly [import("@vue/language-core").VirtualCode, import("@vue/language-core").SourceFile] | readonly [undefined, undefined];
+    };
+    ts: typeof ts;
+    vueOptions: VueCompilerOptions;
+} | undefined;

package/lib/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProject = exports.projects = exports.pipeTable = void 0;
+const os = require("os");
+const path = require("path");
+exports.pipeTable = path.join(os.tmpdir(), 'vue-tsp-table.json');
+exports.projects = new Map();
+function getProject(fileName) {
+    for (const [project, data] of exports.projects) {
+        if (project.containsFile(fileName)) {
+            return data;
+        }
+    }
+}
+exports.getProject = getProject;
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "2.0.0",
+	"version": "2.0.2",
 	"license": "MIT",
 	"files": [
-		"out/**/*.js",
-		"out/**/*.d.ts"
+		"**/*.js",
+		"**/*.d.ts"
 	],
 	"repository": {
 		"type": "git",
@@ -13,11 +13,11 @@
 	},
 	"dependencies": {
 		"@volar/typescript": "~2.1.0",
-		"@vue/language-core": "2.0.0",
+		"@vue/language-core": "2.0.2",
 		"@vue/shared": "^3.4.0"
 	},
 	"devDependencies": {
 		"@types/node": "latest"
 	},
-	"gitHead": "aa47e5a7d8a6dae62cc80dbdb5db6a9bfa4f8715"
+	"gitHead": "b377d5f990ffe7ef44f0d1871fcb8b5c2deafad1"
 }