@vue/typescript-plugin 2.1.10 → 2.2.2

package/lib/utils.d.ts

@@ -1,16 +1,31 @@
-import * as net from 'net';
+import { FileMap } from '@vue/language-core';
+import * as net from 'node:net';
 import type * as ts from 'typescript';
-import type { ProjectInfo, Request } from './server';
+import type { ComponentPropInfo } from './requests/getComponentProps';
+import type { NotificationData, ProjectInfo, RequestData } from './server';
 export { TypeScriptProjectHost } from '@volar/typescript';
-export declare const onSomePipeReadyCallbacks: (() => void)[];
-export declare function getNamedPipePath(projectKind: ts.server.ProjectKind.Configured | ts.server.ProjectKind.Inferred, key: number): string;
-export declare function getReadyNamedPipePaths(): {
-    configured: string[];
-    inferred: string[];
-};
-export declare function connect(namedPipePath: string, timeout?: number): Promise<net.Socket | "error" | "timeout">;
-export declare function searchNamedPipeServerForFile(fileName: string): Promise<{
-    socket: net.Socket;
-    projectInfo: ProjectInfo;
-} | undefined>;
-export declare function sendRequestWorker<T>(request: Request, socket: net.Socket): Promise<T | null | undefined>;
+export declare function getServerPath(kind: ts.server.ProjectKind, id: number): string;
+declare class NamedPipeServer {
+    path: string;
+    connecting: boolean;
+    projectInfo?: ProjectInfo;
+    containsFileCache: Map<string, Promise<boolean | null | undefined>>;
+    componentNamesAndProps: FileMap<Record<string, ComponentPropInfo[] | null>>;
+    constructor(kind: ts.server.ProjectKind, id: number);
+    containsFile(fileName: string): Promise<boolean | null | undefined> | undefined;
+    getComponentProps(fileName: string, tag: string): Promise<ComponentPropInfo[] | null | undefined>;
+    update(): void;
+    connect(): void;
+    close(): void;
+    socket?: net.Socket;
+    seq: number;
+    dataChunks: Buffer[];
+    requestHandlers: Map<number, (res: any) => void>;
+    onData(chunk: Buffer): void;
+    onNotification(type: NotificationData[0], fileName: string, data: any): void;
+    sendRequest<T>(requestType: RequestData[1], fileName: string, ...args: any[]): Promise<T | null | undefined>;
+}
+export declare const configuredServers: NamedPipeServer[];
+export declare const inferredServers: NamedPipeServer[];
+export declare const onServerReady: (() => void)[];
+export declare function getBestServer(fileName: string): Promise<NamedPipeServer | undefined>;

package/lib/utils.js

@@ -1,195 +1,232 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onSomePipeReadyCallbacks = void 0;
-exports.getNamedPipePath = getNamedPipePath;
-exports.getReadyNamedPipePaths = getReadyNamedPipePaths;
-exports.connect = connect;
-exports.searchNamedPipeServerForFile = searchNamedPipeServerForFile;
-exports.sendRequestWorker = sendRequestWorker;
-const fs = require("fs");
-const net = require("net");
-const os = require("os");
-const path = require("path");
+exports.onServerReady = exports.inferredServers = exports.configuredServers = void 0;
+exports.getServerPath = getServerPath;
+exports.getBestServer = getBestServer;
+const language_core_1 = require("@vue/language-core");
+const shared_1 = require("@vue/shared");
+const fs = require("node:fs");
+const net = require("node:net");
+const os = require("node:os");
+const path = require("node:path");
 const { version } = require('../package.json');
 const platform = os.platform();
 const pipeDir = platform === 'win32'
-    ? `\\\\.\\pipe`
-    : `/tmp`;
-const toFullPath = (file) => {
-    if (platform === 'win32') {
-        return pipeDir + '\\' + file;
+    ? `\\\\.\\pipe\\`
+    : `/tmp/`;
+function getServerPath(kind, id) {
+    if (kind === 1) {
+        return `${pipeDir}vue-named-pipe-${version}-configured-${id}`;
     }
     else {
-        return pipeDir + '/' + file;
-    }
-};
-const configuredNamedPipePathPrefix = toFullPath(`vue-named-pipe-${version}-configured-`);
-const inferredNamedPipePathPrefix = toFullPath(`vue-named-pipe-${version}-inferred-`);
-const pipes = new Map();
-exports.onSomePipeReadyCallbacks = [];
-function waitingForNamedPipeServerReady(namedPipePath) {
-    const socket = net.connect(namedPipePath);
-    const start = Date.now();
-    socket.on('connect', () => {
-        console.log('[Vue Named Pipe Client] Connected:', namedPipePath, 'in', (Date.now() - start) + 'ms');
-        socket.write('ping');
-    });
-    socket.on('data', () => {
-        console.log('[Vue Named Pipe Client] Ready:', namedPipePath, 'in', (Date.now() - start) + 'ms');
-        pipes.set(namedPipePath, 'ready');
-        socket.end();
-        exports.onSomePipeReadyCallbacks.forEach(cb => cb());
-    });
-    socket.on('error', err => {
-        if (err.code === 'ECONNREFUSED') {
-            try {
-                console.log('[Vue Named Pipe Client] Deleting:', namedPipePath);
-                fs.promises.unlink(namedPipePath);
-            }
-            catch { }
-        }
-        pipes.delete(namedPipePath);
-        socket.end();
-    });
-    socket.on('timeout', () => {
-        pipes.delete(namedPipePath);
-        socket.end();
-    });
-}
-function getNamedPipePath(projectKind, key) {
-    return projectKind === 1
-        ? `${configuredNamedPipePathPrefix}${key}`
-        : `${inferredNamedPipePathPrefix}${key}`;
+        return `${pipeDir}vue-named-pipe-${version}-inferred-${id}`;
+    }
 }
-function getReadyNamedPipePaths() {
-    const configuredPipes = [];
-    const inferredPipes = [];
-    for (let i = 0; i < 20; i++) {
-        const configuredPipe = getNamedPipePath(1, i);
-        const inferredPipe = getNamedPipePath(0, i);
-        if (pipes.get(configuredPipe) === 'ready') {
-            configuredPipes.push(configuredPipe);
-        }
-        else if (!pipes.has(configuredPipe)) {
-            pipes.set(configuredPipe, 'unknown');
-            waitingForNamedPipeServerReady(configuredPipe);
+class NamedPipeServer {
+    constructor(kind, id) {
+        this.connecting = false;
+        this.containsFileCache = new Map();
+        this.componentNamesAndProps = new language_core_1.FileMap(false);
+        this.seq = 0;
+        this.dataChunks = [];
+        this.requestHandlers = new Map();
+        this.path = getServerPath(kind, id);
+    }
+    containsFile(fileName) {
+        if (this.projectInfo) {
+            if (!this.containsFileCache.has(fileName)) {
+                this.containsFileCache.set(fileName, (async () => {
+                    const res = await this.sendRequest('containsFile', fileName);
+                    if (typeof res !== 'boolean') {
+                        // If the request fails, delete the cache
+                        this.containsFileCache.delete(fileName);
+                    }
+                    return res;
+                })());
+            }
+            return this.containsFileCache.get(fileName);
         }
-        if (pipes.get(inferredPipe) === 'ready') {
-            inferredPipes.push(inferredPipe);
+    }
+    async getComponentProps(fileName, tag) {
+        const componentAndProps = this.componentNamesAndProps.get(fileName);
+        if (!componentAndProps) {
+            return;
         }
-        else if (!pipes.has(inferredPipe)) {
-            pipes.set(inferredPipe, 'unknown');
-            waitingForNamedPipeServerReady(inferredPipe);
+        const props = componentAndProps[tag]
+            ?? componentAndProps[(0, shared_1.camelize)(tag)]
+            ?? componentAndProps[(0, shared_1.capitalize)((0, shared_1.camelize)(tag))];
+        if (props) {
+            return props;
         }
+        return await this.sendRequest('subscribeComponentProps', fileName, tag);
     }
-    return {
-        configured: configuredPipes,
-        inferred: inferredPipes,
-    };
-}
-function connect(namedPipePath, timeout) {
-    return new Promise(resolve => {
-        const socket = net.connect(namedPipePath);
-        if (timeout) {
-            socket.setTimeout(timeout);
+    update() {
+        if (!this.connecting && !this.projectInfo) {
+            this.connecting = true;
+            this.connect();
         }
-        const onConnect = () => {
-            cleanup();
-            resolve(socket);
-        };
-        const onError = (err) => {
+    }
+    connect() {
+        this.socket = net.connect(this.path);
+        this.socket.on('data', this.onData.bind(this));
+        this.socket.on('connect', async () => {
+            const projectInfo = await this.sendRequest('projectInfo', '');
+            if (projectInfo) {
+                console.log('TSServer project ready:', projectInfo.name);
+                this.projectInfo = projectInfo;
+                this.containsFileCache.clear();
+                exports.onServerReady.forEach(cb => cb());
+            }
+            else {
+                this.close();
+            }
+        });
+        this.socket.on('error', err => {
             if (err.code === 'ECONNREFUSED') {
                 try {
-                    console.log('[Vue Named Pipe Client] Deleting:', namedPipePath);
-                    fs.promises.unlink(namedPipePath);
+                    console.log('Deleteing invalid named pipe file:', this.path);
+                    fs.promises.unlink(this.path);
                 }
                 catch { }
             }
-            pipes.delete(namedPipePath);
-            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);
-    });
+            this.close();
+        });
+        this.socket.on('timeout', () => {
+            this.close();
+        });
+    }
+    close() {
+        this.connecting = false;
+        this.projectInfo = undefined;
+        this.socket?.end();
+    }
+    onData(chunk) {
+        this.dataChunks.push(chunk);
+        const data = Buffer.concat(this.dataChunks);
+        const text = data.toString();
+        if (text.endsWith('\n\n')) {
+            this.dataChunks.length = 0;
+            const results = text.split('\n\n');
+            for (let result of results) {
+                result = result.trim();
+                if (!result) {
+                    continue;
+                }
+                try {
+                    const data = JSON.parse(result.trim());
+                    if (typeof data[0] === 'number') {
+                        const [seq, res] = data;
+                        this.requestHandlers.get(seq)?.(res);
+                    }
+                    else {
+                        const [type, fileName, res] = data;
+                        this.onNotification(type, fileName, res);
+                    }
+                }
+                catch (e) {
+                    console.error('JSON parse error:', e);
+                }
+            }
+        }
+    }
+    onNotification(type, fileName, data) {
+        // console.log(`[${type}] ${fileName} ${JSON.stringify(data)}`);
+        if (type === 'componentNamesUpdated') {
+            let components = this.componentNamesAndProps.get(fileName);
+            if (!components) {
+                components = {};
+                this.componentNamesAndProps.set(fileName, components);
+            }
+            const newNames = data;
+            const newNameSet = new Set(newNames);
+            for (const name in components) {
+                if (!newNameSet.has(name)) {
+                    delete components[name];
+                }
+            }
+            for (const name of newNames) {
+                if (!components[name]) {
+                    components[name] = null;
+                }
+            }
+        }
+        else if (type === 'componentPropsUpdated') {
+            const components = this.componentNamesAndProps.get(fileName) ?? {};
+            const [name, props] = data;
+            components[name] = props;
+        }
+        else {
+            console.error('Unknown notification type:', type);
+            debugger;
+        }
+    }
+    sendRequest(requestType, fileName, ...args) {
+        return new Promise(resolve => {
+            const seq = this.seq++;
+            // console.time(`[${seq}] ${requestType} ${fileName}`);
+            this.requestHandlers.set(seq, data => {
+                // console.timeEnd(`[${seq}] ${requestType} ${fileName}`);
+                this.requestHandlers.delete(seq);
+                resolve(data);
+                clearInterval(retryTimer);
+            });
+            const retry = () => {
+                const data = [seq, requestType, fileName, ...args];
+                this.socket.write(JSON.stringify(data) + '\n\n');
+            };
+            retry();
+            const retryTimer = setInterval(retry, 1000);
+        });
+    }
 }
-async function searchNamedPipeServerForFile(fileName) {
-    const paths = await getReadyNamedPipePaths();
-    const configuredServers = (await Promise.all(paths.configured.map(async (path) => {
-        // Find existing servers
-        const socket = await connect(path);
-        if (typeof socket !== 'object') {
+exports.configuredServers = [];
+exports.inferredServers = [];
+exports.onServerReady = [];
+for (let i = 0; i < 10; i++) {
+    exports.configuredServers.push(new NamedPipeServer(1, i));
+    exports.inferredServers.push(new NamedPipeServer(0, i));
+}
+async function getBestServer(fileName) {
+    for (const server of exports.configuredServers) {
+        server.update();
+    }
+    let servers = (await Promise.all(exports.configuredServers.map(async (server) => {
+        const projectInfo = server.projectInfo;
+        if (!projectInfo) {
             return;
         }
-        // Find servers containing the current file
-        const containsFile = await sendRequestWorker({ type: 'containsFile', args: [fileName] }, socket);
+        const containsFile = await server.containsFile(fileName);
         if (!containsFile) {
-            socket.end();
-            return;
-        }
-        // Get project info for each server
-        const projectInfo = await sendRequestWorker({ type: 'projectInfo', args: [fileName] }, socket);
-        if (!projectInfo) {
-            socket.end();
             return;
         }
-        return {
-            socket,
-            projectInfo,
-        };
+        return server;
     }))).filter(server => !!server);
     // Sort servers by tsconfig
-    configuredServers.sort((a, b) => sortTSConfigs(fileName, a.projectInfo.name, b.projectInfo.name));
-    if (configuredServers.length) {
-        // Close all but the first server
-        for (let i = 1; i < configuredServers.length; i++) {
-            configuredServers[i].socket.end();
-        }
+    servers.sort((a, b) => sortTSConfigs(fileName, a.projectInfo.name, b.projectInfo.name));
+    if (servers.length) {
         // Return the first server
-        return configuredServers[0];
+        return servers[0];
     }
-    const inferredServers = (await Promise.all(paths.inferred.map(async (namedPipePath) => {
-        // Find existing servers
-        const socket = await connect(namedPipePath);
-        if (typeof socket !== 'object') {
-            return;
-        }
-        // Get project info for each server
-        const projectInfo = await sendRequestWorker({ type: 'projectInfo', args: [fileName] }, socket);
+    for (const server of exports.inferredServers) {
+        server.update();
+    }
+    servers = (await Promise.all(exports.inferredServers.map(server => {
+        const projectInfo = server.projectInfo;
         if (!projectInfo) {
-            socket.end();
             return;
         }
         // Check if the file is in the project's directory
-        if (!path.relative(projectInfo.currentDirectory, fileName).startsWith('..')) {
-            return {
-                socket,
-                projectInfo,
-            };
+        if (path.relative(projectInfo.currentDirectory, fileName).startsWith('..')) {
+            return;
         }
+        return server;
     }))).filter(server => !!server);
     // Sort servers by directory
-    inferredServers.sort((a, b) => b.projectInfo.currentDirectory.replace(/\\/g, '/').split('/').length
+    servers.sort((a, b) => b.projectInfo.currentDirectory.replace(/\\/g, '/').split('/').length
         - a.projectInfo.currentDirectory.replace(/\\/g, '/').split('/').length);
-    if (inferredServers.length) {
-        // Close all but the first server
-        for (let i = 1; i < inferredServers.length; i++) {
-            inferredServers[i].socket.end();
-        }
+    if (servers.length) {
         // Return the first server
-        return inferredServers[0];
+        return servers[0];
     }
 }
 function sortTSConfigs(file, a, b) {
@@ -208,37 +245,4 @@ function isFileInDir(fileName, dir) {
     const relative = path.relative(dir, fileName);
     return !!relative && !relative.startsWith('..') && !path.isAbsolute(relative);
 }
-function sendRequestWorker(request, socket) {
-    return new Promise(resolve => {
-        let dataChunks = [];
-        const onData = (chunk) => {
-            dataChunks.push(chunk);
-            const data = Buffer.concat(dataChunks);
-            const text = data.toString();
-            if (text.endsWith('\n\n')) {
-                let json = null;
-                try {
-                    json = JSON.parse(text);
-                }
-                catch (e) {
-                    console.error('[Vue Named Pipe Client] Failed to parse response:', text);
-                }
-                cleanup();
-                resolve(json);
-            }
-        };
-        const onError = (err) => {
-            console.error('[Vue Named Pipe Client] Error:', err.message);
-            cleanup();
-            resolve(undefined);
-        };
-        const cleanup = () => {
-            socket.off('data', onData);
-            socket.off('error', onError);
-        };
-        socket.on('data', onData);
-        socket.on('error', onError);
-        socket.write(JSON.stringify(request));
-    });
-}
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "2.1.10",
+	"version": "2.2.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,12 +13,12 @@
 		"directory": "packages/typescript-plugin"
 	},
 	"dependencies": {
-		"@volar/typescript": "~2.4.8",
-		"@vue/language-core": "2.1.10",
+		"@volar/typescript": "~2.4.11",
+		"@vue/language-core": "2.2.2",
 		"@vue/shared": "^3.5.0"
 	},
 	"devDependencies": {
-		"@types/node": "latest"
+		"@types/node": "^22.10.4"
 	},
-	"gitHead": "b0af30caee2f8dfb1a8393c1b400f38e31fa4883"
+	"gitHead": "30757908b67f40f779c36795665163634fb81868"
 }