@kerebron/extension-lsp 0.4.1

package/esm/extension-lsp/src/LSPClient.d.ts

@@ -0,0 +1,56 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+import { TextDocumentSyncKind } from 'vscode-languageserver-protocol';
+import { LspSource, Workspace, WorkspaceFile } from './workspace.js';
+export type Transport = {
+    connect(): void;
+    disconnect(): void;
+    send(message: string): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    isConnected(): boolean;
+    isInitialized(): boolean;
+};
+export type LSPClientConfig = {
+    rootUri?: string;
+    workspace?: (client: LSPClient) => Workspace;
+    timeout?: number;
+    sanitizeHTML?: (html: string) => string;
+    unhandledNotification?: (client: LSPClient, method: string, params: any) => void;
+};
+export declare class LSPError extends Error {
+    isTimeout: boolean;
+    readonly isLSP = true;
+    static createTimeout(): LSPError;
+}
+export declare class LSPClient extends EventTarget {
+    private readonly transport;
+    readonly config: LSPClientConfig;
+    sources: Record<string, LspSource>;
+    workspace: Workspace;
+    private nextReqID;
+    private requests;
+    serverCapabilities: lsp.ServerCapabilities | null;
+    supportSync: TextDocumentSyncKind;
+    private readonly timeout;
+    private initializing;
+    private readonly receiveListener;
+    active: boolean;
+    constructor(transport: Transport, config?: LSPClientConfig);
+    startInitializing(): void;
+    stopInitializing(): void;
+    restart(): Promise<void>;
+    onInitialized(): void;
+    connect(uri: string, source: LspSource): void;
+    disconnect(uri: string): void;
+    didOpen(file: WorkspaceFile): Promise<boolean>;
+    didClose(uri: string): void;
+    private receiveMessage;
+    request<Params, Result>(method: string, params: Params): Promise<Result>;
+    private requestInner;
+    notification<Params>(method: string, params: Params): Promise<boolean>;
+    cancelRequest(params: any): void;
+    hasCapability(name: keyof lsp.ServerCapabilities): boolean | null;
+    sync(): void;
+    private timeoutRequest;
+}
+//# sourceMappingURL=LSPClient.d.ts.map

package/esm/extension-lsp/src/LSPClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LSPClient.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/LSPClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAEL,oBAAoB,EACrB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAEL,SAAS,EACT,SAAS,EACT,aAAa,EACd,MAAM,gBAAgB,CAAC;AA0BxB,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,IAAI,IAAI,CAAC;IACnB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC;IACR,mBAAmB,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,GAAG,IAAI,EACnD,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,GACvC,IAAI,CAAC;IACR,WAAW,IAAI,OAAO,CAAC;IACvB,aAAa,IAAI,OAAO,CAAC;CAC1B,CAAC;AAiEF,MAAM,MAAM,eAAe,GAAG;IAE5B,OAAO,CAAC,EAAE,MAAM,CAAC;IAMjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,SAAS,CAAC;IAG7C,OAAO,CAAC,EAAE,MAAM,CAAC;IAOjB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAGxC,qBAAqB,CAAC,EAAE,CACtB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,GAAG,KACR,IAAI,CAAC;CACX,CAAC;AAEF,qBAAa,QAAS,SAAQ,KAAK;IACjC,SAAS,UAAS;IAClB,QAAQ,CAAC,KAAK,QAAQ;IAEtB,MAAM,CAAC,aAAa;CAKrB;AAED,qBAAa,SAAU,SAAQ,WAAW;IAiBtC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe;IAjBlC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAM;IAExC,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAsB;IAEtC,kBAAkB,EAAE,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAQ;IAClD,WAAW,EAAE,oBAAoB,CAA6B;IAErE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,YAAY,CAA6C;IAEjE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IACrE,MAAM,EAAE,OAAO,CAAS;gBAGL,SAAS,EAAE,SAAS,EAC5B,MAAM,GAAE,eAAoB;IAuCvC,iBAAiB;IAoCjB,gBAAgB;IAOV,OAAO;IASb,aAAa;IAQb,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS;IAWtC,UAAU,CAAC,GAAG,EAAE,MAAM;IAahB,OAAO,CAAC,IAAI,EAAE,aAAa;IAmBjC,QAAQ,CAAC,GAAG,EAAE,MAAM;IASpB,OAAO,CAAC,cAAc;IA+ChB,OAAO,CAAC,MAAM,EAAE,MAAM,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC;IAalB,OAAO,CAAC,YAAY;IA8Cd,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB5E,aAAa,CAAC,MAAM,EAAE,GAAG;IAOzB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,kBAAkB;IAIhD,IAAI;IAIJ,OAAO,CAAC,cAAc;CAcvB"}

package/esm/extension-lsp/src/LSPClient.js

@@ -0,0 +1,449 @@
+import { MessageType, TextDocumentSyncKind, } from 'vscode-languageserver-protocol';
+import { DefaultWorkspace, } from './workspace.js';
+const defaultNotificationHandlers = {
+    'window/logMessage': (client, params) => {
+        if (params.type == MessageType.Error) {
+            console.error('[lsp] ' + params.message);
+        }
+        else if (params.type == MessageType.Warning) {
+            console.warn('[lsp] ' + params.message);
+        }
+        else if (params.type == MessageType.Info) {
+            console.info('[lsp] ' + params.message);
+        }
+        else if (params.type == MessageType.Log) {
+            console.log('[lsp] ' + params.message);
+        }
+    },
+    'window/showMessage': (client, params) => {
+        if (params.type > MessageType.Info)
+            return;
+        for (const f of client.workspace.files) {
+            const ui = f.getUi();
+            if (!ui)
+                continue;
+            ui.showMessage(params.message);
+        }
+    },
+};
+class Request {
+    constructor(id, params, timeout) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: id
+        });
+        Object.defineProperty(this, "params", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: params
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: timeout
+        });
+        Object.defineProperty(this, "promise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+const clientCapabilities = {
+    general: {
+        markdown: {
+            parser: 'marked',
+        },
+    },
+    textDocument: {
+        publishDiagnostics: { versionSupport: true },
+        completion: {
+            completionItem: {
+                snippetSupport: true,
+                documentationFormat: ['plaintext', 'markdown'],
+                insertReplaceSupport: false,
+            },
+            completionList: {
+                itemDefaults: ['commitCharacters', 'editRange', 'insertTextFormat'],
+            },
+            completionItemKind: { valueSet: [] },
+            contextSupport: true,
+        },
+        hover: {
+            contentFormat: ['markdown', 'plaintext'],
+        },
+        // formatting: {},
+        // rename: {},
+        signatureHelp: {
+            contextSupport: true,
+            signatureInformation: {
+                documentationFormat: ['markdown', 'plaintext'],
+                parameterInformation: { labelOffsetSupport: true },
+                activeParameterSupport: true,
+            },
+        },
+        definition: {},
+        declaration: {},
+        implementation: {},
+        typeDefinition: {},
+        references: {},
+        diagnostic: {},
+    },
+    window: {
+        showMessage: {},
+    },
+};
+export class LSPError extends Error {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "isTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isLSP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    static createTimeout() {
+        const err = new LSPError('Request timed out');
+        err.isTimeout = true;
+        return err;
+    }
+}
+export class LSPClient extends EventTarget {
+    constructor(transport, config = {}) {
+        super();
+        Object.defineProperty(this, "transport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: transport
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "sources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "workspace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nextReqID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "requests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "serverCapabilities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "supportSync", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: TextDocumentSyncKind.None
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initializing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "receiveListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "active", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.timeout = config.timeout ?? 3000;
+        this.receiveListener = (event) => this.receiveMessage(event);
+        transport.addEventListener('message', this.receiveListener);
+        transport.addEventListener('initialized', () => {
+            try {
+                console.info('LSP initialized');
+                this.onInitialized();
+            }
+            catch (err) {
+                if (err.isLSP) {
+                    console.error('Timeout as client.onConnected()', err.message, this.onInitialized);
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+        transport.addEventListener('open', () => {
+            this.startInitializing();
+        });
+        transport.addEventListener('close', (event) => {
+            this.active = false;
+            this.serverCapabilities = null;
+            this.dispatchEvent(new CloseEvent('close'));
+        });
+        this.workspace = config.workspace
+            ? config.workspace(this)
+            : new DefaultWorkspace(this);
+    }
+    startInitializing() {
+        if (this.initializing) {
+            return;
+        }
+        this.initializing = setInterval(async () => {
+            const capabilities = clientCapabilities;
+            try {
+                const resp = await this.requestInner('initialize', {
+                    processId: null,
+                    clientInfo: { name: '@kerebron/lsp-client' },
+                    rootUri: this.config.rootUri || null,
+                    capabilities,
+                }).promise;
+                this.stopInitializing();
+                this.serverCapabilities = resp.capabilities;
+                const sync = this.serverCapabilities.textDocumentSync;
+                this.supportSync = TextDocumentSyncKind.None;
+                if (sync) {
+                    this.supportSync = typeof sync == 'number'
+                        ? sync
+                        : sync.change ?? TextDocumentSyncKind.None;
+                }
+                // deno-lint-ignore no-empty
+            }
+            catch (ignoreConnectErrors) { }
+        }, this.timeout);
+    }
+    stopInitializing() {
+        if (this.initializing) {
+            clearInterval(this.initializing);
+            this.initializing = undefined;
+        }
+    }
+    async restart() {
+        this.active = true;
+        if (!this.transport.isConnected()) {
+            this.transport.connect();
+        }
+        else {
+            this.startInitializing();
+        }
+    }
+    onInitialized() {
+        this.transport.send(JSON.stringify({ jsonrpc: '2.0', method: 'initialized', params: {} }));
+        this.workspace.connected();
+    }
+    connect(uri, source) {
+        if (this.sources[uri] && this.sources[uri] !== source) {
+            throw new Error(`Source for ${uri} already connected`);
+        }
+        this.sources[uri] = source;
+        this.active = true;
+        if (!this.transport.isConnected()) {
+            this.transport.connect();
+        }
+    }
+    disconnect(uri) {
+        delete this.sources[uri];
+        this.workspace.closeFile(uri);
+        if (Object.keys(this.sources).length === 0) {
+            this.active = false;
+            this.serverCapabilities = null;
+            this.transport.removeEventListener('data', this.receiveListener);
+            this.workspace.disconnected();
+            this.dispatchEvent(new CloseEvent('close'));
+        }
+    }
+    /// Send a `textDocument/didOpen` notification to the server.
+    async didOpen(file) {
+        if (!this.transport.isInitialized()) {
+            return false;
+        }
+        await this.notification('textDocument/didOpen', {
+            textDocument: {
+                uri: file.uri,
+                languageId: file.languageId,
+                text: file.content,
+                version: file.version,
+            },
+        });
+        return true;
+    }
+    /// Send a `textDocument/didClose` notification to the server.
+    didClose(uri) {
+        if (!this.transport.isInitialized()) {
+            return;
+        }
+        this.notification('textDocument/didClose', {
+            textDocument: { uri },
+        });
+    }
+    receiveMessage(event) {
+        const msg = event.data;
+        const value = JSON.parse(msg);
+        if ('id' in value && !('method' in value)) {
+            const index = this.requests.findIndex((r) => r.id == value.id);
+            if (index < 0) {
+                console.warn(`[lsp] Received a response for non-existent request ${value.id}`);
+            }
+            else {
+                const req = this.requests[index];
+                clearTimeout(req.timeout);
+                this.requests.splice(index, 1);
+                if (value.error)
+                    req.reject(value.error);
+                else
+                    req.resolve(value.result);
+            }
+        }
+        else if (!('id' in value)) {
+            const event = new CustomEvent(value.method, {
+                detail: { params: value.params },
+            });
+            if (this.dispatchEvent(event)) {
+                if (this.config.unhandledNotification) {
+                    this.config.unhandledNotification(this, value.method, value.params);
+                }
+                else {
+                    if (defaultNotificationHandlers[value.method]) {
+                        defaultNotificationHandlers[value.method](this, value.params);
+                    }
+                }
+            }
+        }
+        else {
+            const resp = {
+                jsonrpc: '2.0',
+                id: value.id,
+                error: {
+                    code: -32601, /* MethodNotFound */
+                    message: 'Method not implemented',
+                },
+            };
+            this.transport.send(JSON.stringify(resp));
+        }
+    }
+    async request(method, params) {
+        if (!this.transport.isConnected()) {
+            if (this.active) {
+                this.transport.connect();
+            }
+            throw new LSPError('Not connected');
+        }
+        const retVal = await this.requestInner(method, params)
+            .promise;
+        return retVal;
+    }
+    requestInner(method, params, mapped = false) {
+        if (!this.transport) {
+            throw new Error('No transport');
+        }
+        if (!this.transport.isConnected()) {
+            if (this.active) {
+                this.transport.connect();
+            }
+            throw new Error('Transport not connected');
+        }
+        const id = ++this.nextReqID, data = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params: params,
+        };
+        const req = new Request(id, params, setTimeout(() => this.timeoutRequest(req, method, id, params), this.timeout));
+        try {
+            if (!this.transport) {
+                throw new LSPError('No transport');
+            }
+            this.transport.send(JSON.stringify(data));
+            this.requests.push(req);
+        }
+        catch (e) {
+            console.error(e);
+            clearTimeout(req.timeout);
+            req.reject(e);
+        }
+        return req;
+    }
+    async notification(method, params) {
+        if (!this.transport)
+            return false;
+        if (!this.transport.isConnected()) {
+            if (this.active) {
+                this.transport.connect();
+            }
+            return false;
+        }
+        if (!this.transport.isInitialized()) {
+            return false;
+        }
+        const data = {
+            jsonrpc: '2.0',
+            method,
+            params: params,
+        };
+        this.transport.send(JSON.stringify(data));
+        return true;
+    }
+    cancelRequest(params) {
+        const found = this.requests.find((r) => r.params === params);
+        if (found) {
+            this.notification('$/cancelRequest', found.id);
+        }
+    }
+    hasCapability(name) {
+        return this.serverCapabilities ? !!this.serverCapabilities[name] : null;
+    }
+    sync() {
+        this.workspace.syncFiles();
+    }
+    timeoutRequest(req, method, id, params) {
+        console.error('this.timeoutRequest', this.timeout, method, id, params);
+        const index = this.requests.indexOf(req);
+        if (index > -1) {
+            req.reject(LSPError.createTimeout());
+            this.requests.splice(index, 1);
+        }
+    }
+}

package/esm/extension-lsp/src/LspWebSocketTransport.d.ts

@@ -0,0 +1,20 @@
+import "../../_dnt.polyfills.js";
+import { type Transport } from './LSPClient.js';
+export declare class LspWebSocketTransport extends EventTarget implements Transport {
+    readonly uri: string;
+    socket: WebSocket | undefined;
+    private reconnectAttempts;
+    private maxAttempts;
+    private readonly baseDelay;
+    isConnecting: boolean;
+    initialized: boolean;
+    constructor(uri: string);
+    isConnected(): boolean;
+    isInitialized(): boolean;
+    connect(): void;
+    disconnect(): void;
+    bindEvents(socket: WebSocket): void;
+    scheduleReconnect(): void;
+    send(message: string): void;
+}
+//# sourceMappingURL=LspWebSocketTransport.d.ts.map

package/esm/extension-lsp/src/LspWebSocketTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LspWebSocketTransport.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/LspWebSocketTransport.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAShD,qBAAa,qBAAsB,SAAQ,WAAY,YAAW,SAAS;aAQ7C,GAAG,EAAE,MAAM;IAPvC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,YAAY,EAAE,OAAO,CAAS;IAC9B,WAAW,UAAS;gBAEQ,GAAG,EAAE,MAAM;IAIvC,WAAW;IAIX,aAAa;IAIb,OAAO;IAWP,UAAU,IAAI,IAAI;IAQlB,UAAU,CAAC,MAAM,EAAE,SAAS;IAqC5B,iBAAiB;IAiBjB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAW5B"}

package/esm/extension-lsp/src/LspWebSocketTransport.js

@@ -0,0 +1,137 @@
+import "../../_dnt.polyfills.js";
+function shouldReconnectOnCode(code) {
+    // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+    // Reconnect on server going away (1001), but NOT on normal close (1000)
+    const reconnectCodes = [1001, 1005, 1006, 1011, 1012, 1013];
+    return reconnectCodes.includes(code);
+}
+export class LspWebSocketTransport extends EventTarget {
+    constructor(uri) {
+        super();
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: uri
+        });
+        Object.defineProperty(this, "socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "maxAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "baseDelay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        Object.defineProperty(this, "isConnecting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    isConnected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    connect() {
+        if (this.isConnecting) {
+            return;
+        }
+        this.isConnecting = true;
+        this.socket?.close();
+        const socket = new WebSocket(this.uri);
+        this.bindEvents(socket);
+        this.socket = socket;
+    }
+    disconnect() {
+        console.info('LSP transport disconnect()');
+        this.socket?.close();
+        this.socket = undefined;
+        this.initialized = false;
+        this.reconnectAttempts = 0;
+    }
+    bindEvents(socket) {
+        socket.addEventListener('message', (event) => {
+            try {
+                const json = JSON.parse(event.data);
+                if (json?.result?.capabilities) {
+                    this.reconnectAttempts = 0;
+                    this.initialized = true;
+                    this.dispatchEvent(new Event('initialized'));
+                }
+                // deno-lint-ignore no-empty
+            }
+            catch (ignoredError) { }
+            this.dispatchEvent(new MessageEvent('message', { data: event.data }));
+        });
+        socket.addEventListener('open', (event) => {
+            this.isConnecting = false;
+            this.dispatchEvent(new CustomEvent('open'));
+        });
+        socket.addEventListener('error', (event) => {
+            console.error(event);
+            this.dispatchEvent(event);
+        });
+        socket.addEventListener('close', (event) => {
+            this.isConnecting = false;
+            this.dispatchEvent(new CloseEvent('close', {
+                code: event.code,
+            }));
+            this.socket = undefined;
+            if (!event.wasClean || shouldReconnectOnCode(event.code)) {
+                this.scheduleReconnect();
+            }
+            else {
+                console.info('Clean close — no reconnect');
+            }
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxAttempts) {
+            console.error('Max reconnect attempts reached');
+            return;
+        }
+        const delay = this.baseDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts++;
+        console.info(`Reconnecting in ${delay}ms... (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            this.connect();
+        }, delay);
+    }
+    send(message) {
+        if (!this.socket) {
+            console.warn('Socket disconnected');
+            return;
+        }
+        if (this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(message);
+        }
+        else {
+            console.warn('WebSocket not open: ' + this.socket.readyState);
+        }
+    }
+}

package/esm/extension-lsp/src/computeIncrementalChanges.d.ts

@@ -0,0 +1,8 @@
+import * as lsp from 'vscode-languageserver-protocol';
+/**
+ * Compares two strings and computes the minimal set of text changes
+ * using a diff-based approach (simple line-by-line + character diff for simplicity).
+ * Returns an array of TextEdit-like changes that transform `previous` into `current`.
+ */
+export declare function computeIncrementalChanges(previous: string, current: string): lsp.TextDocumentContentChangeEvent[];
+//# sourceMappingURL=computeIncrementalChanges.d.ts.map

package/esm/extension-lsp/src/computeIncrementalChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeIncrementalChanges.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/computeIncrementalChanges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,gCAAgC,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,GAAG,CAAC,8BAA8B,EAAE,CA0FtC"}