ts-const-value-transformer 0.9.0 → 0.10.0

package/dist/lsp/SyncLspClient.mjs

@@ -0,0 +1,234 @@
+// @internal
+import * as console from 'console';
+// @internal
+import { SyncChildProcess } from 'sync-child-process';
+export default class SyncLspClient {
+    /** process */
+    _p;
+    _id;
+    /** received data */
+    _r;
+    /** server message handlers */
+    _s;
+    /** notification handlers */
+    _n;
+    /** last buffer */
+    _l;
+    /** encoding */
+    _e;
+    constructor(command, argv, encoding = 'utf8') {
+        this._p = new SyncChildProcess(command, argv);
+        this._id = 0;
+        this._r = [];
+        this._s = [];
+        this._n = [];
+        this._e = encoding;
+    }
+    sendRaw(jsonRpc) {
+        const jsonRpcStr = JSON.stringify(jsonRpc);
+        // console.log(`sending: ${jsonRpcStr}`);
+        const contentLength = Buffer.from(jsonRpcStr, this._e).byteLength;
+        this._p.stdin.write(`Content-Length: ${contentLength}\r\n\r\n${jsonRpcStr}`);
+    }
+    sendMessage(method, params) {
+        const id = this._id++;
+        const jsonRpcRequest = {
+            jsonrpc: '2.0',
+            id,
+            method,
+        };
+        if (params) {
+            jsonRpcRequest.params = params;
+        }
+        this.sendRaw(jsonRpcRequest);
+        return id;
+    }
+    notifyMessage(method, params) {
+        const jsonRpcRequest = {
+            jsonrpc: '2.0',
+            method,
+        };
+        if (params) {
+            jsonRpcRequest.params = params;
+        }
+        this.sendRaw(jsonRpcRequest);
+    }
+    pushReceived(json) {
+        try {
+            const jsonData = JSON.parse(json);
+            // console.log('Received:', jsonData);
+            if (typeof jsonData !== 'object' || !jsonData) {
+                return;
+            }
+            if (!('jsonrpc' in jsonData) || jsonData.jsonrpc !== '2.0') {
+                return;
+            }
+            if ('id' in jsonData) {
+                if ('method' in jsonData) {
+                    for (let s = this._s, l = s.length, i = 0; i < l; ++i) {
+                        const o = s[i];
+                        if (o.method === jsonData.method) {
+                            const r = o.callback(o.method, jsonData.params);
+                            this.sendRaw({
+                                jsonrpc: '2.0',
+                                id: jsonData.id,
+                                result: r ?? null,
+                            });
+                            break;
+                        }
+                    }
+                }
+                else {
+                    this._r.push(jsonData);
+                }
+            }
+            else if ('method' in jsonData) {
+                for (let n = this._n.slice(), l = n.length, i = 0; i < l; ++i) {
+                    const o = n[i];
+                    if (o.method === jsonData.method) {
+                        o.callback(o.method, jsonData.params);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    pumpMessage(flushOnly = false) {
+        let returnIfNoData = flushOnly;
+        for (;;) {
+            const lastBuffer = this._l;
+            this._l = null;
+            if (lastBuffer) {
+                const headers = {};
+                let start = 0;
+                let cur = 0;
+                while (cur < lastBuffer.length) {
+                    const c = lastBuffer[cur];
+                    if (c === 10 ||
+                        (c === 13 &&
+                            cur < lastBuffer.length - 1 &&
+                            lastBuffer[cur + 1] === 10)) {
+                        if (start === cur) {
+                            if (c === 13) {
+                                ++cur;
+                            }
+                            ++cur;
+                            break;
+                        }
+                        const headerLine = lastBuffer
+                            .subarray(start, cur)
+                            .toString(this._e);
+                        const [n, v = ''] = headerLine.split(':', 2);
+                        headers[n.trim().toLowerCase()] = v.trim();
+                        if (c === 13) {
+                            ++cur;
+                        }
+                        start = cur + 1;
+                    }
+                    ++cur;
+                }
+                if (cur === lastBuffer.length) {
+                    // buffer is not enough
+                    this._l = lastBuffer;
+                }
+                else {
+                    // If no content-length, drop
+                    if (headers['content-length'] != null) {
+                        const last = cur + (Number(headers['content-length']) || 0);
+                        if (last > lastBuffer.length) {
+                            // buffer is not enough
+                            this._l = lastBuffer;
+                        }
+                        else {
+                            const bin = lastBuffer.subarray(cur, last);
+                            if (last < lastBuffer.length) {
+                                this._l = lastBuffer.subarray(last);
+                            }
+                            this.pushReceived(bin.toString(this._e));
+                            returnIfNoData = true;
+                            continue;
+                        }
+                    }
+                }
+            }
+            if (returnIfNoData) {
+                return true;
+            }
+            for (;;) {
+                const r = this._p.next();
+                if (r.done) {
+                    return false;
+                }
+                const recv = r.value;
+                if (recv.type === 'stderr') {
+                    console.error(recv.data.toString(this._e));
+                    continue;
+                }
+                this._l = this._l ? Buffer.concat([this._l, recv.data]) : recv.data;
+                break;
+            }
+        }
+    }
+    receiveMessage(id) {
+        for (;;) {
+            for (let r = this._r, i = 0, l = r.length; i < l; ++i) {
+                const obj = r[i];
+                if (obj.id === id) {
+                    r.splice(i, 1);
+                    return obj.result;
+                }
+            }
+            if (!this.pumpMessage()) {
+                throw new Error('Peer closed');
+            }
+        }
+    }
+    registerServerMessageHandler(method, callback, once = false) {
+        // eslint-disable-next-line prefer-const
+        let unsub;
+        if (once) {
+            const cb = ((callback) => (method, params) => {
+                const r = callback(method, params);
+                unsub();
+                return r;
+            })(callback);
+            callback = cb;
+        }
+        this._s.push({ method, callback });
+        unsub = () => {
+            for (let s = this._s, l = s.length, i = 0; i < l; ++i) {
+                const o = s[i];
+                if (o.method === method && o.callback === callback) {
+                    s.splice(i, 1);
+                    break;
+                }
+            }
+        };
+        return unsub;
+    }
+    registerNotificationHandler(method, callback, once = false) {
+        // eslint-disable-next-line prefer-const
+        let unsub;
+        if (once) {
+            const cb = ((callback) => (method, params) => {
+                callback(method, params);
+                unsub();
+            })(callback);
+            callback = cb;
+        }
+        this._n.push({ method, callback });
+        unsub = () => {
+            for (let n = this._n, l = n.length, i = 0; i < l; ++i) {
+                const o = n[i];
+                if (o.method === method && o.callback === callback) {
+                    n.splice(i, 1);
+                    break;
+                }
+            }
+        };
+        return unsub;
+    }
+    close() {
+        this._p.stdin.end();
+    }
+}

package/dist/lsp/TsLspClient.d.mts

@@ -0,0 +1,29 @@
+import SyncLspClient from './SyncLspClient.mjs';
+export default class TsLspClient extends SyncLspClient {
+    private _supportPullDiagnostics;
+    private _firstDiagnosticsReceived;
+    private readonly _fileForDiagnostics;
+    constructor(command: string, argv: string[], encoding?: BufferEncoding);
+    initialize(rootDir: string): void;
+    waitForFirstDiagnosticsReceived(): void;
+    openDocument(fileName: string, content: string): void;
+    closeDocument(fileName: string): void;
+    /** Only returns first string from contents */
+    hoverForPosition(fileName: string, line: number, pos: number): [markdown: boolean, value: string];
+    getDefinition(fileName: string, line: number, pos: number): {
+        fileName: string;
+        lineStart: number;
+        posStart: number;
+        lineEnd: number;
+        posEnd: number;
+    } | null;
+    getTypeDefitition(fileName: string, line: number, pos: number): {
+        fileName: string;
+        lineStart: number;
+        posStart: number;
+        lineEnd: number;
+        posEnd: number;
+    } | null;
+    sendReplaceText(fileName: string, lineStart: number, posStart: number, lineEnd: number, posEnd: number, text: string): void;
+    exit(): void;
+}

package/dist/lsp/TsLspClient.mjs

@@ -0,0 +1,271 @@
+// @internal
+import { fileURLToPath, pathToFileURL } from 'url';
+// @internal
+import version from '../version.mjs';
+import SyncLspClient from './SyncLspClient.mjs';
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+export default class TsLspClient extends SyncLspClient {
+    _supportPullDiagnostics;
+    _firstDiagnosticsReceived;
+    _fileForDiagnostics;
+    constructor(command, argv, encoding = 'utf8') {
+        super(command, argv, encoding);
+        this._supportPullDiagnostics = false;
+        this._firstDiagnosticsReceived = false;
+        this._fileForDiagnostics = new Map();
+        this.registerServerMessageHandler('client/registerCapability', () => {
+            return null;
+        });
+        this.registerServerMessageHandler('workspace/configuration', () => {
+            return {};
+        });
+        this.registerNotificationHandler('textDocument/publishDiagnostics', () => {
+            this._firstDiagnosticsReceived = true;
+        }, true);
+    }
+    initialize(rootDir) {
+        const uri = pathToFileURL(rootDir).href;
+        const id = this.sendMessage('initialize', {
+            processId: process.pid,
+            clientInfo: {
+                name: 'ts-const-value-transformer',
+                version,
+            },
+            capabilities: {
+                textDocument: {
+                    publishDiagnostics: {
+                        relatedInformation: true,
+                    },
+                    diagnostics: {
+                        relatedInformation: true,
+                    },
+                    declaration: {
+                        linkSupport: false,
+                    },
+                    typeDefinition: {
+                        linkSupport: false,
+                    },
+                    hover: {
+                        contentFormat: ['markdown', 'plaintext'],
+                    },
+                },
+            },
+            workspaceFolders: [{ name: 'workspace', uri }],
+            rootUri: uri,
+            initializationOptions: {},
+        });
+        const r = this.receiveMessage(id);
+        if (r?.capabilities == null) {
+            throw new Error('Unexpected language server: no capabilities');
+        }
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!r.capabilities.hoverProvider) {
+            throw new Error('Unexpected language server: hover not supported');
+        }
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!r.capabilities.typeDefinitionProvider) {
+            throw new Error('Unexpected language server: go to type definition not supported');
+        }
+        this._supportPullDiagnostics = r.capabilities.diagnosticProvider != null;
+        this.notifyMessage('initialized');
+        if (!this.pumpMessage(true)) {
+            throw new Error('Peer closed');
+        }
+        if (!this._supportPullDiagnostics) {
+            this.registerNotificationHandler('textDocument/publishDiagnostics', (_, params) => {
+                if (!params || !('uri' in params) || !('diagnostics' in params)) {
+                    return;
+                }
+                this._fileForDiagnostics.set(params.uri, params.diagnostics);
+            });
+        }
+    }
+    waitForFirstDiagnosticsReceived() {
+        if (this._firstDiagnosticsReceived) {
+            return;
+        }
+        if (!this.pumpMessage(true)) {
+            throw new Error('Peer closed');
+        }
+        while (!this._firstDiagnosticsReceived) {
+            if (!this.pumpMessage()) {
+                throw new Error('Peer closed');
+            }
+        }
+    }
+    openDocument(fileName, content) {
+        const uri = pathToFileURL(fileName).href;
+        this._fileForDiagnostics.delete(uri);
+        this.notifyMessage('textDocument/didOpen', {
+            textDocument: {
+                uri,
+                languageId: 'typescript',
+                version: 0,
+                text: content,
+            },
+        });
+    }
+    closeDocument(fileName) {
+        const uri = pathToFileURL(fileName).href;
+        this._fileForDiagnostics.delete(uri);
+        this.notifyMessage('textDocument/didClose', {
+            textDocument: {
+                uri,
+            },
+        });
+    }
+    // public receiveDiagnostics(fileName: string): object[] {
+    //   const uri = pathToFileURL(fileName).href;
+    //   if (this._supportPullDiagnostics) {
+    //     const id = this.sendMessage('textDocument/diagnostic', {
+    //       textDocument: {
+    //         uri,
+    //       },
+    //     });
+    //     const r: any = this.receiveMessage(id);
+    //     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    //     if (!r) {
+    //       return [];
+    //     }
+    //     if (r.kind === 'unchanged') {
+    //       return [];
+    //     }
+    //     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    //     return r.items;
+    //   } else {
+    //     if (!this.pumpMessage(true)) {
+    //       throw new Error('Peer closed');
+    //     }
+    //     for (;;) {
+    //       const o = this._fileForDiagnostics.get(uri);
+    //       if (o) {
+    //         return o;
+    //       }
+    //       if (!this.pumpMessage()) {
+    //         throw new Error('Peer closed');
+    //       }
+    //     }
+    //   }
+    // }
+    /** Only returns first string from contents */
+    hoverForPosition(fileName, line, pos) {
+        const uri = pathToFileURL(fileName).href;
+        const id = this.sendMessage('textDocument/hover', {
+            textDocument: {
+                uri,
+            },
+            position: {
+                line,
+                character: pos,
+            },
+        });
+        const r = this.receiveMessage(id);
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!r?.contents) {
+            return [false, ''];
+        }
+        if ('kind' in r.contents) {
+            return [r.contents.kind === 'markdown', r.contents.value];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const c = r.contents instanceof Array ? r.contents[0] : r.contents;
+        if (typeof c === 'string') {
+            return [true, c];
+        }
+        return [true, '```' + c.language + '\n' + c.value + '\n```'];
+    }
+    getDefinition(fileName, line, pos) {
+        const uri = pathToFileURL(fileName).href;
+        const id = this.sendMessage('textDocument/definition', {
+            textDocument: {
+                uri,
+            },
+            position: {
+                line,
+                character: pos,
+            },
+        });
+        const r = this.receiveMessage(id);
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!r) {
+            return null;
+        }
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+        const loc = r instanceof Array ? r[0] : r;
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!loc) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const defFileName = fileURLToPath(loc.uri);
+        return {
+            fileName: defFileName,
+            lineStart: loc.range.start.line,
+            posStart: loc.range.start.character,
+            lineEnd: loc.range.end.line,
+            posEnd: loc.range.end.character,
+        };
+        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+    }
+    getTypeDefitition(fileName, line, pos) {
+        const uri = pathToFileURL(fileName).href;
+        const id = this.sendMessage('textDocument/typeDefinition', {
+            textDocument: {
+                uri,
+            },
+            position: {
+                line,
+                character: pos,
+            },
+        });
+        const r = this.receiveMessage(id);
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!r) {
+            return null;
+        }
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+        const loc = r instanceof Array ? r[0] : r;
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!loc) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const defFileName = fileURLToPath(loc.uri);
+        return {
+            fileName: defFileName,
+            lineStart: loc.range.start.line,
+            posStart: loc.range.start.character,
+            lineEnd: loc.range.end.line,
+            posEnd: loc.range.end.character,
+        };
+        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+    }
+    sendReplaceText(fileName, lineStart, posStart, lineEnd, posEnd, text) {
+        const uri = pathToFileURL(fileName).href;
+        this._fileForDiagnostics.delete(uri);
+        this.notifyMessage('textDocument/didChange', {
+            textDocument: {
+                uri,
+                version: 0,
+            },
+            contentChanges: [
+                {
+                    range: {
+                        start: { line: lineStart, character: posStart },
+                        end: { line: lineEnd, character: posEnd },
+                    },
+                    text,
+                },
+            ],
+        });
+    }
+    exit() {
+        const id = this.sendMessage('shutdown');
+        try {
+            this.receiveMessage(id);
+            this.notifyMessage('exit');
+        }
+        catch { }
+        this.close();
+    }
+}

package/dist/lsp/lspTransformerUtil.d.mts

@@ -0,0 +1 @@
+export {};