@vue/typescript-plugin 2.1.10 → 2.2.2

package/lib/requests/getComponentProps.d.ts

@@ -0,0 +1,9 @@
+import type { RequestContext } from './types';
+export interface ComponentPropInfo {
+    name: string;
+    required?: boolean;
+    deprecated?: boolean;
+    commentMarkdown?: string;
+    values?: string[];
+}
+export declare function getComponentProps(this: RequestContext, fileName: string, tag: string): ComponentPropInfo[] | undefined;

package/lib/requests/getComponentProps.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentProps = getComponentProps;
+const language_core_1 = require("@vue/language-core");
+const utils_1 = require("./utils");
+function getComponentProps(fileName, tag) {
+    const { typescript: ts, language, languageService, getFileId } = this;
+    const volarFile = language.scripts.get(getFileId(fileName));
+    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
+        return;
+    }
+    const vueCode = volarFile.generated.root;
+    const program = languageService.getProgram();
+    const checker = program.getTypeChecker();
+    const components = (0, utils_1.getVariableType)(ts, languageService, vueCode, '__VLS_components');
+    if (!components) {
+        return [];
+    }
+    const componentType = (0, utils_1.getComponentType)(ts, languageService, vueCode, components, fileName, tag);
+    if (!componentType) {
+        return [];
+    }
+    const result = new Map();
+    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) {
+                const name = prop.name;
+                const required = !(prop.flags & ts.SymbolFlags.Optional) || undefined;
+                const { content: commentMarkdown, deprecated } = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags());
+                result.set(name, {
+                    name,
+                    required,
+                    deprecated,
+                    commentMarkdown
+                });
+            }
+        }
+    }
+    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;
+                }
+                const name = prop.name;
+                const required = !(prop.flags & ts.SymbolFlags.Optional) || undefined;
+                const { content: commentMarkdown, deprecated } = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags());
+                result.set(name, {
+                    name,
+                    required,
+                    deprecated,
+                    commentMarkdown
+                });
+            }
+        }
+    }
+    return [...result.values()];
+}
+function generateCommentMarkdown(parts, jsDocTags) {
+    const parsedComment = _symbolDisplayPartsToMarkdown(parts);
+    const parsedJsDoc = _jsDocTagInfoToMarkdown(jsDocTags);
+    const content = [parsedComment, parsedJsDoc].filter(str => !!str).join('\n\n');
+    const deprecated = jsDocTags.some(tag => tag.name === 'deprecated');
+    return {
+        content,
+        deprecated
+    };
+}
+function _symbolDisplayPartsToMarkdown(parts) {
+    return parts.map(part => {
+        switch (part.kind) {
+            case 'keyword':
+                return `\`${part.text}\``;
+            case 'functionName':
+                return `**${part.text}**`;
+            default:
+                return part.text;
+        }
+    }).join('');
+}
+function _jsDocTagInfoToMarkdown(jsDocTags) {
+    return jsDocTags.map(tag => {
+        const tagName = `*@${tag.name}*`;
+        const tagText = tag.text?.map(t => {
+            if (t.kind === 'parameterName') {
+                return `\`${t.text}\``;
+            }
+            else {
+                return t.text;
+            }
+        }).join('') || '';
+        return `${tagName} ${tagText}`;
+    }).join('\n\n');
+}
+//# sourceMappingURL=getComponentProps.js.map

package/lib/requests/getElementAttrs.d.ts

@@ -0,0 +1,2 @@
+import type { RequestContext } from './types';
+export declare function getElementAttrs(this: RequestContext, fileName: string, tagName: string): string[] | undefined;

package/lib/requests/getElementAttrs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementAttrs = getElementAttrs;
+const vue = require("@vue/language-core");
+function getElementAttrs(fileName, tagName) {
+    const { typescript: ts, language, languageService, getFileId } = this;
+    const volarFile = language.scripts.get(getFileId(fileName));
+    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
+        return;
+    }
+    const program = languageService.getProgram();
+    let tsSourceFile;
+    if (tsSourceFile = program.getSourceFile(fileName)) {
+        const checker = program.getTypeChecker();
+        const typeNode = tsSourceFile.statements
+            .filter(ts.isTypeAliasDeclaration)
+            .find(node => node.name.getText() === '__VLS_IntrinsicElementsCompletion');
+        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 [];
+}
+//# sourceMappingURL=getElementAttrs.js.map

package/lib/requests/getSlotNames.d.ts

@@ -0,0 +1,6 @@
+import type { RequestContext } from './types';
+export interface ElementAttrInfo {
+    name: string;
+    values?: string[];
+}
+export declare function getSlotNames(this: RequestContext, fileName: string): string[] | undefined;

package/lib/requests/getSlotNames.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSlotNames = getSlotNames;
+const language_core_1 = require("@vue/language-core");
+function getSlotNames(fileName) {
+    const { typescript: ts, language, languageService, getFileId } = this;
+    const sourceScript = language.scripts.get(getFileId(fileName));
+    if (!sourceScript?.generated) {
+        return;
+    }
+    const root = sourceScript.generated.root;
+    if (!(root instanceof language_core_1.VueVirtualCode)) {
+        return;
+    }
+    const program = languageService.getProgram();
+    const tsSourceFile = program.getSourceFile(fileName);
+    if (!tsSourceFile) {
+        return;
+    }
+    const checker = program.getTypeChecker();
+    const typeNode = tsSourceFile.statements
+        .filter(ts.isTypeAliasDeclaration)
+        .find(node => node.name.getText() === '__VLS_Slots');
+    if (typeNode) {
+        const attrs = checker.getTypeFromTypeNode(typeNode.type).getProperties();
+        return attrs.map(attr => attr.name);
+    }
+    return [];
+}
+//# sourceMappingURL=getSlotNames.js.map

package/lib/requests/goToDefinition.d.ts

@@ -0,0 +1,2 @@
+import type { RequestContext } from './types';
+export declare function goToDefinition(this: RequestContext, fileName: string, tag: string): string | undefined;

package/lib/requests/goToDefinition.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goToDefinition = goToDefinition;
+const vue = require("@vue/language-core");
+const componentInfos_1 = require("./componentInfos");
+function goToDefinition(fileName, tag) {
+    const { typescript: ts, language, languageService, getFileId } = this;
+    const volarFile = language.scripts.get(getFileId(fileName));
+    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
+        return;
+    }
+    const vueCode = volarFile.generated.root;
+    const components = (0, componentInfos_1.getVariableType)(ts, languageService, vueCode, '__VLS_components');
+    if (!components) {
+        return '';
+    }
+    const componentType = (0, componentInfos_1.getComponentType)(ts, languageService, vueCode, components, fileName, tag);
+    if (!componentType) {
+        return '';
+    }
+    const decls = componentType.symbol.declarations ?? [];
+    for (const decl of decls) {
+        return decl.getSourceFile().fileName;
+    }
+}
+//# sourceMappingURL=goToDefinition.js.map

package/lib/requests/types.d.ts

@@ -1,7 +1,7 @@
 import type { Language } from '@vue/language-core';
 import type * as ts from 'typescript';
 export interface RequestContext<T = any> {
-    typescript: typeof import('typescript');
+    typescript: typeof ts;
     languageService: ts.LanguageService;
     languageServiceHost: ts.LanguageServiceHost;
     language: Language<T>;

package/lib/requests/utils.d.ts

@@ -0,0 +1,8 @@
+import type { VueVirtualCode } from '@vue/language-core';
+import type * as ts from 'typescript';
+export declare function getComponentType(ts: typeof import('typescript'), languageService: ts.LanguageService, vueCode: VueVirtualCode, components: NonNullable<ReturnType<typeof getVariableType>>, fileName: string, tag: string): ts.Type | undefined;
+export declare function getSelfComponentName(fileName: string): Capitalize<string>;
+export declare function getVariableType(ts: typeof import('typescript'), languageService: ts.LanguageService, vueCode: VueVirtualCode, name: string): {
+    node: ts.Node;
+    type: ts.Type;
+} | undefined;

package/lib/requests/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentType = getComponentType;
+exports.getSelfComponentName = getSelfComponentName;
+exports.getVariableType = getVariableType;
+const shared_1 = require("@vue/shared");
+const path = require("node:path");
+function getComponentType(ts, languageService, vueCode, components, fileName, tag) {
+    const program = languageService.getProgram();
+    const checker = program.getTypeChecker();
+    const name = tag.split('.');
+    let componentSymbol = components.type.getProperty(name[0])
+        ?? components.type.getProperty((0, shared_1.camelize)(name[0]))
+        ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
+    let componentType;
+    if (!componentSymbol) {
+        const name = getSelfComponentName(fileName);
+        if (name === (0, shared_1.capitalize)((0, shared_1.camelize)(tag))) {
+            componentType = getVariableType(ts, languageService, vueCode, '__VLS_self')?.type;
+        }
+    }
+    else {
+        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);
+            }
+        }
+    }
+    return componentType;
+}
+function getSelfComponentName(fileName) {
+    const baseName = path.basename(fileName);
+    return (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
+}
+function getVariableType(ts, languageService, vueCode, name) {
+    const program = languageService.getProgram();
+    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=utils.js.map

package/lib/server.d.ts

@@ -1,9 +1,22 @@
-import type { Language } from '@vue/language-core';
+import { Language } from '@vue/language-core';
 import type * as ts from 'typescript';
-export interface Request {
-    type: 'containsFile' | 'projectInfo' | 'collectExtractProps' | 'getImportPathForFile' | 'getPropertiesAtLocation' | 'getQuickInfoAtPosition' | 'getComponentProps' | 'getComponentEvents' | 'getTemplateContextProps' | 'getComponentNames' | 'getElementAttrs';
-    args: [fileName: string, ...rest: any];
-}
+export type RequestType = 'containsFile' | 'projectInfo' | 'collectExtractProps' | 'getImportPathForFile' | 'getPropertiesAtLocation' | 'getQuickInfoAtPosition' | 'subscribeComponentProps' | 'getComponentEvents' | 'getComponentDirectives' | 'getElementAttrs';
+export type NotificationType = 'componentNamesUpdated' | 'componentPropsUpdated';
+export type RequestData = [
+    seq: number,
+    type: RequestType,
+    fileName: string,
+    ...args: any[]
+];
+export type ResponseData = [
+    seq: number,
+    data: any
+];
+export type NotificationData = [
+    type: NotificationType,
+    fileName: string,
+    data: any
+];
 export interface ProjectInfo {
     name: string;
     kind: ts.server.ProjectKind;

package/lib/server.js

@@ -1,91 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startNamedPipeServer = startNamedPipeServer;
-const fs = require("fs");
-const net = require("net");
+const language_core_1 = require("@vue/language-core");
+const fs = require("node:fs");
+const net = require("node:net");
 const collectExtractProps_1 = require("./requests/collectExtractProps");
-const componentInfos_1 = require("./requests/componentInfos");
+const getComponentDirectives_1 = require("./requests/getComponentDirectives");
+const getComponentEvents_1 = require("./requests/getComponentEvents");
+const getComponentNames_1 = require("./requests/getComponentNames");
+const getComponentProps_1 = require("./requests/getComponentProps");
+const getElementAttrs_1 = require("./requests/getElementAttrs");
 const getImportPathForFile_1 = require("./requests/getImportPathForFile");
 const getPropertiesAtLocation_1 = require("./requests/getPropertiesAtLocation");
 const getQuickInfoAtPosition_1 = require("./requests/getQuickInfoAtPosition");
 const utils_1 = require("./utils");
 async function startNamedPipeServer(ts, info, language, projectKind) {
+    let lastProjectVersion;
+    const requestContext = {
+        typescript: ts,
+        languageService: info.languageService,
+        languageServiceHost: info.languageServiceHost,
+        language: language,
+        isTsPlugin: true,
+        getFileId: (fileName) => fileName,
+    };
+    const dataChunks = [];
+    const currentData = new language_core_1.FileMap(false);
+    const allConnections = new Set();
+    const pendingRequests = new Set();
     const server = net.createServer(connection => {
-        connection.on('data', data => {
-            const text = data.toString();
-            if (text === 'ping') {
-                connection.write('pong');
-                return;
-            }
-            const request = JSON.parse(text);
-            const fileName = request.args[0];
-            const requestContext = {
-                typescript: ts,
-                languageService: info.languageService,
-                languageServiceHost: info.languageServiceHost,
-                language: language,
-                isTsPlugin: true,
-                getFileId: (fileName) => fileName,
-            };
-            if (request.type === 'containsFile') {
-                sendResponse(info.project.containsFile(ts.server.toNormalizedPath(fileName)));
-            }
-            else if (request.type === 'projectInfo') {
-                sendResponse({
-                    name: info.project.getProjectName(),
-                    kind: info.project.projectKind,
-                    currentDirectory: info.project.getCurrentDirectory(),
-                });
-            }
-            else if (request.type === 'collectExtractProps') {
-                const result = collectExtractProps_1.collectExtractProps.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getImportPathForFile') {
-                const result = getImportPathForFile_1.getImportPathForFile.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getPropertiesAtLocation') {
-                const result = getPropertiesAtLocation_1.getPropertiesAtLocation.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getQuickInfoAtPosition') {
-                const result = getQuickInfoAtPosition_1.getQuickInfoAtPosition.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            // Component Infos
-            else if (request.type === 'getComponentProps') {
-                const result = componentInfos_1.getComponentProps.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getComponentEvents') {
-                const result = componentInfos_1.getComponentEvents.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getTemplateContextProps') {
-                const result = componentInfos_1.getTemplateContextProps.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getComponentNames') {
-                const result = componentInfos_1.getComponentNames.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else if (request.type === 'getElementAttrs') {
-                const result = componentInfos_1.getElementAttrs.apply(requestContext, request.args);
-                sendResponse(result);
-            }
-            else {
-                console.warn('[Vue Named Pipe Server] Unknown request type:', request.type);
+        allConnections.add(connection);
+        connection.on('end', () => {
+            allConnections.delete(connection);
+        });
+        connection.on('data', buffer => {
+            dataChunks.push(buffer);
+            const text = dataChunks.toString();
+            if (text.endsWith('\n\n')) {
+                dataChunks.length = 0;
+                const requests = text.split('\n\n');
+                for (let json of requests) {
+                    json = json.trim();
+                    if (!json) {
+                        continue;
+                    }
+                    try {
+                        onRequest(connection, JSON.parse(json));
+                    }
+                    catch (e) {
+                        console.error('[Vue Named Pipe Server] JSON parse error:', e);
+                    }
+                }
             }
         });
         connection.on('error', err => console.error('[Vue Named Pipe Server]', err.message));
-        function sendResponse(data) {
-            connection.write(JSON.stringify(data ?? null) + '\n\n');
+        for (const [fileName, [componentNames, componentProps]] of currentData) {
+            notify(connection, 'componentNamesUpdated', fileName, componentNames);
+            for (const [name, props] of Object.entries(componentProps)) {
+                notify(connection, 'componentPropsUpdated', fileName, [name, props]);
+            }
         }
     });
-    for (let i = 0; i < 20; i++) {
-        const path = (0, utils_1.getNamedPipePath)(projectKind, i);
-        const socket = await (0, utils_1.connect)(path, 100);
+    for (let i = 0; i < 10; i++) {
+        const path = (0, utils_1.getServerPath)(projectKind, i);
+        const socket = await connect(path, 100);
         if (typeof socket === 'object') {
             socket.end();
         }
@@ -98,6 +76,164 @@ async function startNamedPipeServer(ts, info, language, projectKind) {
             break;
         }
     }
+    updateWhile();
+    async function updateWhile() {
+        while (true) {
+            await sleep(500);
+            const projectVersion = info.project.getProjectVersion();
+            if (lastProjectVersion === projectVersion) {
+                continue;
+            }
+            const connections = [...allConnections].filter(c => !c.destroyed);
+            if (!connections.length) {
+                continue;
+            }
+            const token = info.languageServiceHost.getCancellationToken?.();
+            const openedScriptInfos = info.project.getRootScriptInfos().filter(info => info.isScriptOpen());
+            if (!openedScriptInfos.length) {
+                continue;
+            }
+            for (const scriptInfo of openedScriptInfos) {
+                await sleep(10);
+                if (token?.isCancellationRequested()) {
+                    break;
+                }
+                let data = currentData.get(scriptInfo.fileName);
+                if (!data) {
+                    data = [[], {}];
+                    currentData.set(scriptInfo.fileName, data);
+                }
+                const [oldComponentNames, componentProps] = data;
+                const newComponentNames = getComponentNames_1.getComponentNames.apply(requestContext, [scriptInfo.fileName]) ?? [];
+                if (JSON.stringify(oldComponentNames) !== JSON.stringify(newComponentNames)) {
+                    data[0] = newComponentNames;
+                    for (const connection of connections) {
+                        notify(connection, 'componentNamesUpdated', scriptInfo.fileName, newComponentNames);
+                    }
+                }
+                for (const [name, props] of Object.entries(componentProps)) {
+                    await sleep(10);
+                    if (token?.isCancellationRequested()) {
+                        break;
+                    }
+                    const newProps = getComponentProps_1.getComponentProps.apply(requestContext, [scriptInfo.fileName, name]) ?? [];
+                    if (JSON.stringify(props) !== JSON.stringify(newProps)) {
+                        componentProps[name] = newProps;
+                        for (const connection of connections) {
+                            notify(connection, 'componentPropsUpdated', scriptInfo.fileName, [name, newProps]);
+                        }
+                    }
+                }
+            }
+            lastProjectVersion = projectVersion;
+        }
+    }
+    function sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    function notify(connection, type, fileName, data) {
+        connection.write(JSON.stringify([type, fileName, data]) + '\n\n');
+    }
+    function onRequest(connection, [seq, requestType, ...args]) {
+        if (pendingRequests.has(seq)) {
+            return;
+        }
+        setTimeout(() => pendingRequests.delete(seq), 500);
+        pendingRequests.add(seq);
+        let data;
+        try {
+            data = handleRequest(requestType, ...args);
+        }
+        catch {
+            data = null;
+        }
+        connection.write(JSON.stringify([seq, data ?? null]) + '\n\n');
+    }
+    function handleRequest(requestType, ...args) {
+        const fileName = args[0];
+        if (requestType === 'projectInfo') {
+            return {
+                name: info.project.getProjectName(),
+                kind: info.project.projectKind,
+                currentDirectory: info.project.getCurrentDirectory(),
+            };
+        }
+        else if (requestType === 'containsFile') {
+            return info.project.containsFile(ts.server.toNormalizedPath(fileName));
+        }
+        else if (requestType === 'collectExtractProps') {
+            return collectExtractProps_1.collectExtractProps.apply(requestContext, args);
+        }
+        else if (requestType === 'getImportPathForFile') {
+            return getImportPathForFile_1.getImportPathForFile.apply(requestContext, args);
+        }
+        else if (requestType === 'getPropertiesAtLocation') {
+            return getPropertiesAtLocation_1.getPropertiesAtLocation.apply(requestContext, args);
+        }
+        else if (requestType === 'getQuickInfoAtPosition') {
+            return getQuickInfoAtPosition_1.getQuickInfoAtPosition.apply(requestContext, args);
+        }
+        else if (requestType === 'subscribeComponentProps') {
+            const tag = args[1];
+            const props = getComponentProps_1.getComponentProps.apply(requestContext, [fileName, tag]) ?? [];
+            let data = currentData.get(fileName);
+            if (!data) {
+                data = [[], {}];
+                currentData.set(fileName, data);
+            }
+            data[1][tag] = props;
+            return props;
+        }
+        else if (requestType === 'getComponentEvents') {
+            return getComponentEvents_1.getComponentEvents.apply(requestContext, args);
+        }
+        else if (requestType === 'getComponentDirectives') {
+            return getComponentDirectives_1.getComponentDirectives.apply(requestContext, args);
+        }
+        else if (requestType === 'getElementAttrs') {
+            return getElementAttrs_1.getElementAttrs.apply(requestContext, args);
+        }
+        console.warn('[Vue Named Pipe Server] Unknown request:', requestType);
+        debugger;
+        return undefined;
+    }
+}
+function connect(namedPipePath, timeout) {
+    return new Promise(resolve => {
+        const socket = net.connect(namedPipePath);
+        if (timeout) {
+            socket.setTimeout(timeout);
+        }
+        const onConnect = () => {
+            cleanup();
+            resolve(socket);
+        };
+        const onError = (err) => {
+            if (err.code === 'ECONNREFUSED') {
+                try {
+                    console.log('[Vue Named Pipe Client] Deleting:', namedPipePath);
+                    fs.promises.unlink(namedPipePath);
+                }
+                catch { }
+            }
+            cleanup();
+            resolve('error');
+            socket.end();
+        };
+        const onTimeout = () => {
+            cleanup();
+            resolve('timeout');
+            socket.end();
+        };
+        const cleanup = () => {
+            socket.off('connect', onConnect);
+            socket.off('error', onError);
+            socket.off('timeout', onTimeout);
+        };
+        socket.on('connect', onConnect);
+        socket.on('error', onError);
+        socket.on('timeout', onTimeout);
+    });
 }
 function tryListen(server, namedPipePath) {
     return new Promise(resolve => {