@kerebron/extension-codemirror 0.3.1 → 0.4.1

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

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

@@ -0,0 +1,82 @@
+/**
+ * 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 function computeIncrementalChanges(previous, current) {
+    if (previous.length === 0) {
+        return [
+            {
+                text: current,
+            },
+        ];
+    }
+    const prevLines = previous.split(/\r\n|\r|\n/);
+    const currLines = current.split(/\r\n|\r|\n/);
+    const changes = [];
+    let startLine = 0;
+    let insertedText = '';
+    // Find common prefix
+    while (startLine < prevLines.length && startLine < currLines.length) {
+        if (prevLines[startLine] === currLines[startLine]) {
+            startLine++;
+        }
+        else {
+            break;
+        }
+    }
+    // If entire document is the same
+    if (startLine === prevLines.length &&
+        startLine === currLines.length) {
+        return changes; // No changes
+    }
+    // Find common suffix starting from the end
+    let endLinePrev = prevLines.length - 1;
+    let endLineCurr = currLines.length - 1;
+    while (endLinePrev >= startLine &&
+        endLineCurr >= startLine &&
+        prevLines[endLinePrev] === currLines[endLineCurr]) {
+        endLinePrev--;
+        endLineCurr--;
+    }
+    // Region to replace: from startLine to endLinePrev (inclusive)
+    const replaceStart = { line: startLine, character: 0 };
+    let replaceEnd;
+    if (endLinePrev >= startLine) {
+        const lastDeletedLine = prevLines[endLinePrev];
+        replaceEnd = {
+            line: endLinePrev,
+            character: lastDeletedLine.length,
+        };
+    }
+    else {
+        // Deletion ends at the start of the next line
+        replaceEnd = { line: startLine, character: 0 };
+    }
+    // Build inserted text: lines from startLine to endLineCurr
+    const insertedLines = currLines.slice(startLine, endLineCurr + 1);
+    insertedText = insertedLines.join('\n');
+    // If we're inserting at the end of the file, adjust range
+    if (startLine === prevLines.length) {
+        // Inserting after last line
+        replaceEnd = {
+            line: prevLines.length - 1,
+            character: prevLines[prevLines.length - 1].length,
+        };
+        if (insertedLines.length === 0) {
+            // Inserting empty at EOF
+            insertedText = '\n';
+        }
+    }
+    // Create the range for deletion
+    const range = {
+        start: replaceStart,
+        end: replaceEnd,
+    };
+    // Push the incremental change
+    changes.push({
+        range,
+        text: insertedText,
+    });
+    return changes;
+}

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

@@ -0,0 +1,23 @@
+import { DefaultRenderer } from '../../extension-autocomplete/src/DefaultRenderer.js';
+import { TextRange } from '../../editor/src/mod.js';
+import { type AutocompleteProps } from '../../extension-autocomplete/src/mod.js';
+import { ExtensionLsp } from './ExtensionLsp.js';
+interface CompletionItem {
+    label: string;
+    detail: string;
+    insertText: string;
+}
+export declare class CustomRenderer extends DefaultRenderer<CompletionItem> {
+    createListItem(item: CompletionItem, cnt: number): any;
+}
+export declare function cleanPlaceholders(input: string): string;
+export declare function createLspAutocomplete(extensionLsp: ExtensionLsp): {
+    autocompleteConfig: {
+        renderer: CustomRenderer;
+        matchers: import("../../extension-autocomplete/src/types.js").AutocompleteMatcher[];
+        getItems: (query: string, props: AutocompleteProps) => Promise<CompletionItem[]>;
+        onSelect: (selected: CompletionItem, range: TextRange) => Promise<void>;
+    };
+};
+export {};
+//# sourceMappingURL=createLspAutocomplete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLspAutocomplete.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/createLspAutocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AACtF,OAAO,EAAmB,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAErE,OAAO,EACL,KAAK,iBAAiB,EAEvB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAe,SAAQ,eAAe,CAAC,cAAc,CAAC;IACxD,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM;CAa1D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY;;;;0BAOpC,MAAM,SAAS,iBAAiB;6BAiC7B,cAAc,SAAS,SAAS;;EAiB9D"}

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

@@ -0,0 +1,68 @@
+import { DefaultRenderer } from '../../extension-autocomplete/src/DefaultRenderer.js';
+import { createRegexMatcher, } from '../../extension-autocomplete/src/mod.js';
+export class CustomRenderer extends DefaultRenderer {
+    createListItem(item, cnt) {
+        const li = document.createElement('li');
+        if (cnt === this.pos) {
+            li.classList.add('active');
+        }
+        li.innerText = item.label;
+        li.title = item.detail;
+        li.style.cursor = 'pointer';
+        li.addEventListener('click', () => {
+            this.command(item);
+        });
+        return li;
+    }
+}
+export function cleanPlaceholders(input) {
+    const regex = /\$\{\d+:([^}]+)}/g;
+    return input.replace(regex, '$1');
+}
+export function createLspAutocomplete(extensionLsp) {
+    const editor = extensionLsp.getEditor();
+    const renderer = new CustomRenderer(editor);
+    const config = {
+        renderer,
+        matchers: [createRegexMatcher([/\w+/, /(^|\s)@\w*/, /^#\w*/])],
+        getItems: async (query, props) => {
+            const { mapper } = extensionLsp.source.getMappedContent();
+            const lspPos = mapper.toRawTextLspPos(props.range.from);
+            const client = extensionLsp.getClient(extensionLsp.mainLang);
+            if (client) {
+                client.sync();
+                try {
+                    const completions = await client.request('textDocument/completion', {
+                        textDocument: { uri: extensionLsp.uri },
+                        position: lspPos,
+                        context: { triggerKind: 2, triggerCharacter: query },
+                    });
+                    if (Array.isArray(completions)) {
+                        return completions;
+                    }
+                    return completions.items;
+                }
+                catch (err) {
+                    console.error(err.message);
+                    return [];
+                }
+            }
+            else {
+                return [];
+            }
+        },
+        onSelect: async (selected, range) => {
+            const rawText = cleanPlaceholders(selected.insertText);
+            const slice = await extensionLsp.extensionMarkdown.fromMarkdown(rawText);
+            if (slice.content.content.length === 1) {
+                const first = slice.content.content[0];
+                if (first.isBlock) {
+                    editor.chain().insertBlockSmart(range.from, first).run();
+                    return;
+                }
+            }
+            editor.chain().replaceRangeSlice(range, slice).run();
+        },
+    };
+    return { autocompleteConfig: config };
+}

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

@@ -0,0 +1,4 @@
+export * from './ExtensionLsp.js';
+export * from './LSPClient.js';
+export * from './workspace.js';
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from './ExtensionLsp.js';
+export * from './LSPClient.js';
+export * from './workspace.js';