@kerebron/extension-menu 0.4.2 → 0.4.4

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/LspStatus.d.ts

@@ -0,0 +1,34 @@
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { MenuElement } from '../../extension-menu/src/mod.js';
+import type { ExtensionLsp } from './ExtensionLsp.js';
+export type LspConnectionStatus = 'connected' | 'connecting' | 'disconnected';
+export interface LspStatusOptions {
+    /** The LSP extension instance to monitor */
+    lspExtension: ExtensionLsp;
+    /** Optional label to show (e.g., 'LSP' or language name) */
+    label?: string;
+}
+/**
+ * A menu element that displays LSP connection status.
+ * Shows a status indicator dot with an optional label.
+ */
+export declare class LspStatusElement implements MenuElement {
+    private lspExtension;
+    private label;
+    private dom;
+    private statusDot;
+    private labelEl;
+    private status;
+    private statusCheckInterval;
+    constructor(options: LspStatusOptions);
+    render(_view: EditorView): {
+        dom: HTMLElement;
+        update: (state: EditorState) => boolean;
+    };
+    private getClient;
+    private updateStatusFromClient;
+    private setStatus;
+    destroy(): void;
+}
+//# sourceMappingURL=LspStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LspStatus.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/LspStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,4CAA4C;IAC5C,YAAY,EAAE,YAAY,CAAC;IAC3B,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,GAAG,CAA4B;IACvC,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,mBAAmB,CAA+C;gBAE9D,OAAO,EAAE,gBAAgB;IAKrC,MAAM,CACJ,KAAK,EAAE,UAAU,GAChB;QAAE,GAAG,EAAE,WAAW,CAAC;QAAC,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAA;KAAE;IAyChE,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,SAAS;IAoBjB,OAAO;CAMR"}

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

@@ -0,0 +1,127 @@
+const CSS_PREFIX = 'kb-lsp-status';
+/**
+ * A menu element that displays LSP connection status.
+ * Shows a status indicator dot with an optional label.
+ */
+export class LspStatusElement {
+    constructor(options) {
+        Object.defineProperty(this, "lspExtension", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "label", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "statusDot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "labelEl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'disconnected'
+        });
+        Object.defineProperty(this, "statusCheckInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.lspExtension = options.lspExtension;
+        this.label = options.label ?? 'LSP';
+    }
+    render(_view) {
+        // Create main container
+        this.dom = document.createElement('div');
+        this.dom.className = CSS_PREFIX;
+        this.dom.setAttribute('role', 'status');
+        this.dom.setAttribute('aria-live', 'polite');
+        // Create status indicator
+        const indicator = document.createElement('div');
+        indicator.className = `${CSS_PREFIX}__indicator`;
+        // Status dot
+        this.statusDot = document.createElement('span');
+        this.statusDot.className =
+            `${CSS_PREFIX}__dot ${CSS_PREFIX}__dot--disconnected`;
+        indicator.appendChild(this.statusDot);
+        // Label
+        this.labelEl = document.createElement('span');
+        this.labelEl.className = `${CSS_PREFIX}__label`;
+        this.labelEl.textContent = this.label;
+        indicator.appendChild(this.labelEl);
+        this.dom.appendChild(indicator);
+        // Set initial status based on client state
+        this.updateStatusFromClient();
+        // Poll for status changes since the client is created lazily
+        this.statusCheckInterval = setInterval(() => {
+            this.updateStatusFromClient();
+        }, 1000);
+        const update = (_state) => {
+            // Always visible
+            return true;
+        };
+        return { dom: this.dom, update };
+    }
+    getClient() {
+        const mainLang = this.lspExtension.mainLang || 'markdown';
+        return this.lspExtension.getClient(mainLang);
+    }
+    updateStatusFromClient() {
+        const client = this.getClient();
+        // Check if the client has server capabilities (meaning it's connected and initialized)
+        if (client?.serverCapabilities) {
+            this.setStatus('connected');
+        }
+        else if (client?.active) {
+            this.setStatus('connecting');
+        }
+        else {
+            this.setStatus('disconnected');
+        }
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return; // No change
+        this.status = status;
+        if (this.statusDot) {
+            this.statusDot.className =
+                `${CSS_PREFIX}__dot ${CSS_PREFIX}__dot--${status}`;
+        }
+        if (this.dom) {
+            this.dom.setAttribute('data-status', status);
+            const statusLabels = {
+                connected: 'LSP Connected',
+                connecting: 'LSP Connecting...',
+                disconnected: 'LSP Disconnected',
+            };
+            this.dom.title = statusLabels[status];
+            this.dom.setAttribute('aria-label', statusLabels[status]);
+        }
+    }
+    destroy() {
+        if (this.statusCheckInterval) {
+            clearInterval(this.statusCheckInterval);
+            this.statusCheckInterval = null;
+        }
+    }
+}

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"}