codemirror-languageserver 1.18.0 → 1.19.0

package/README.md

@@ -14,6 +14,9 @@ https://user-images.githubusercontent.com/348107/120141150-c6bb9180-c1fd-11eb-8a
 - 📚 Hover Documentation
 - 🩺 Diagnostics
 - 🔍 Go to Definition, Declaration, and Type Definition
+- 🔦 Document Highlight
+- 🎨 Document Formatting and Range Formatting
+- ✏️ Rename Symbol
 
 ## Usage
 
@@ -24,8 +27,6 @@ npm i codemirror-languageserver
 ```js
 import { languageServer } from 'codemirror-languageserver';
 
-const transport = new WebSocketTransport(serverUri);
-
 var ls = languageServer({
     // WebSocket server uri and other client options.
     serverUri,
@@ -33,7 +34,7 @@ var ls = languageServer({
 
     // Alternatively, to share the same client across multiple instances of this plugin.
     client: new LanguageServerClient({
-        serverUri,
+        transport: new WebSocketTransport(serverUri),
         rootUri: 'file:///',
     }),
 
@@ -52,6 +53,78 @@ var view = new EditorView({
 });
 ```
 
+### Custom Transport
+
+Use `languageServerWithTransport` to provide a custom transport (e.g. for non-WebSocket connections):
+
+```js
+import { languageServerWithTransport } from 'codemirror-languageserver';
+
+var ls = languageServerWithTransport({
+    transport: myCustomTransport, // Must implement the Transport interface
+    rootUri: 'file:///',
+    documentUri: `file:///${filename}`,
+    languageId: 'cpp',
+});
+```
+
+The `Transport` interface requires `send`, `onMessage`, `onClose`, `onError`, and `close` methods. You can import `Transport` and `WebSocketTransport` from the package.
+
+### Document Highlight
+
+Document highlights are enabled by default. When the cursor is on a symbol, all occurrences are highlighted. Style them with CSS:
+
+```css
+.cm-lsp-highlight-text,
+.cm-lsp-highlight-read { background-color: rgba(255, 255, 0, 0.2); }
+.cm-lsp-highlight-write { background-color: rgba(255, 165, 0, 0.3); }
+```
+
+### Formatting
+
+`formatDocument` and `formatSelection` are CodeMirror commands that you can bind to keys:
+
+```js
+import { keymap } from '@codemirror/view';
+import { formatDocument, formatSelection } from 'codemirror-languageserver';
+
+keymap.of([
+    { key: 'Shift-Alt-f', run: formatDocument },
+    { key: 'Ctrl-k Ctrl-f', run: formatSelection },
+])
+```
+
+To configure formatting options (tab size, spaces vs tabs, etc.), use the `formattingOptions` facet:
+
+```js
+import { formattingOptions } from 'codemirror-languageserver';
+
+// In extensions:
+formattingOptions.of({
+    tabSize: 2,
+    insertSpaces: true,
+    trimTrailingWhitespace: true,
+    insertFinalNewline: true,
+})
+```
+
+By default, `tabSize` is read from the editor state.
+
+### Rename Symbol
+
+`renameSymbol` is a CodeMirror command that opens a rename prompt at the top of the editor:
+
+```js
+import { keymap } from '@codemirror/view';
+import { renameSymbol } from 'codemirror-languageserver';
+
+keymap.of([
+    { key: 'F2', run: renameSymbol },
+])
+```
+
+Style the rename panel with CSS using the `cm-lsp-rename-panel` and `cm-lsp-rename-input` classes.
+
 ### Using with Initialization Options
 
 The plugin includes built-in TypeScript definitions for popular language servers:

package/dist/formatting.d.ts

@@ -0,0 +1,6 @@
+import { Facet } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+import type * as LSP from 'vscode-languageserver-protocol';
+export declare const formattingOptions: Facet<LSP.FormattingOptions, LSP.FormattingOptions>;
+export declare function formatDocument(view: EditorView): boolean;
+export declare function formatSelection(view: EditorView): boolean;

package/dist/highlight.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@codemirror/state';
+export declare const documentHighlight: () => Extension;

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { LanguageServerClient, languageServerPlugin, SynchronizationMethod, } from './plugin';
+export { WebSocketTransport } from './jsonrpc';
+export type { Transport } from './jsonrpc';
 export { jumpToDefinition, jumpToDefinitionPos, jumpToDefinitionKeymap, } from './definition';
+export { formatDocument, formatSelection, formattingOptions, } from './formatting';
+export { renameSymbol } from './rename';
 export { PyrightInitializationOptions, RustAnalyzerInitializationOptions, TypeScriptInitializationOptions, ESLintInitializationOptions, ClangdInitializationOptions, GoplsInitializationOptions, } from './initialization';
 import { LanguageServerClient, SynchronizationMethod } from './plugin';
 import type { LanguageServerClientOptions, LanguageServerBaseOptions } from './plugin';
@@ -12,5 +16,5 @@ interface LanguageServerWebsocketOptions<InitializationOptions = unknown> extend
     serverUri: `ws://${string}` | `wss://${string}`;
     initializationOptions?: InitializationOptions;
 }
-export declare function languageServer<InitializationOptions = unknown>(options: LanguageServerWebsocketOptions<InitializationOptions>): import("@codemirror/state").Extension[];
-export declare function languageServerWithTransport<InitializationOptions = unknown>(options: LanguageServerOptions<InitializationOptions>): import("@codemirror/state").Extension[];
+export declare function languageServer<InitializationOptions = unknown>(options: LanguageServerWebsocketOptions<InitializationOptions>): (import("@codemirror/state").Extension | import("@codemirror/state").StateField<string>)[];
+export declare function languageServerWithTransport<InitializationOptions = unknown>(options: LanguageServerOptions<InitializationOptions>): (import("@codemirror/state").Extension | import("@codemirror/state").StateField<string>)[];

package/dist/index.js

@@ -1,10 +1,120 @@
-import { insertCompletionText, autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
-import { Facet } from '@codemirror/state';
-import { ViewPlugin, hoverTooltip as hoverTooltip$1, EditorView, keymap } from '@codemirror/view';
-import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
-import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind } from 'vscode-languageserver-protocol';
+import { Facet, StateEffect, StateField } from '@codemirror/state';
+import { ViewPlugin, showPanel, hoverTooltip as hoverTooltip$1, EditorView, Decoration, keymap } from '@codemirror/view';
+import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind, DocumentHighlightKind } from 'vscode-languageserver-protocol';
 import { marked } from 'marked';
+import { autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
+
+class WebSocketTransport {
+    constructor(uri) {
+        this.connection = new WebSocket(uri);
+    }
+    send(message) {
+        this.connection.send(message);
+    }
+    onMessage(callback) {
+        this.connection.addEventListener('message', (event) => {
+            callback(typeof event.data === 'string' ? event.data : '');
+        });
+    }
+    onClose(callback) {
+        this.connection.addEventListener('close', callback);
+    }
+    onError(callback) {
+        this.connection.addEventListener('error', () => {
+            callback(new Error('WebSocket error'));
+        });
+    }
+    close() {
+        this.connection.close();
+    }
+}
+class JSONRPCClient {
+    constructor(transport) {
+        this.nextId = 0;
+        this.pending = new Map();
+        this.notificationHandlers = [];
+        this.transport = transport;
+        this.ready = new Promise((resolve, reject) => {
+            if (transport instanceof WebSocketTransport) {
+                const ws = transport.connection;
+                if (ws.readyState === WebSocket.OPEN) {
+                    resolve();
+                }
+                else {
+                    ws.addEventListener('open', () => resolve());
+                    ws.addEventListener('error', () => reject(new Error('WebSocket connection failed')));
+                }
+            }
+            else {
+                resolve();
+            }
+        });
+        transport.onMessage((raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            if ('id' in msg && msg.id != null && this.pending.has(msg.id)) {
+                const pending = this.pending.get(msg.id);
+                this.pending.delete(msg.id);
+                clearTimeout(pending.timer);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message || 'JSON-RPC error'));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+            else if ('method' in msg) {
+                for (const handler of this.notificationHandlers) {
+                    handler(msg);
+                }
+            }
+        });
+    }
+    async request(req, timeout) {
+        await this.ready;
+        const id = this.nextId++;
+        const message = {
+            jsonrpc: '2.0',
+            id,
+            method: req.method,
+            params: req.params,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Request ${req.method} timed out`));
+            }, timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.transport.send(JSON.stringify(message));
+        });
+    }
+    async notify(notification) {
+        await this.ready;
+        const message = {
+            jsonrpc: '2.0',
+            method: notification.method,
+            params: notification.params,
+        };
+        this.transport.send(JSON.stringify(message));
+    }
+    onNotification(handler) {
+        this.notificationHandlers.push(handler);
+    }
+    close() {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Client closed'));
+        }
+        this.pending.clear();
+        this.transport.close();
+    }
+}
 
 function posToOffset(doc, pos) {
     if (pos.line >= doc.lines) {
@@ -46,6 +156,7 @@ function changeSetToEvents(doc, changes) {
 }
 
 const timeout = 10000;
+const changesDelay = 500;
 const CompletionItemKindMap = Object.fromEntries(Object.entries(CompletionItemKind).map(([key, value]) => [value, key]));
 const useLast = (values) => values.reduce((_, v) => v, '');
 Facet.define({
@@ -61,26 +172,19 @@ class LanguageServerClient {
         this.autoClose = options.autoClose;
         this.plugins = [];
         this.transport = options.transport;
-        this.requestManager = new RequestManager([this.transport]);
-        this.client = new Client(this.requestManager);
+        this.client = new JSONRPCClient(this.transport);
         this.client.onNotification((data) => {
+            if (data.method && data.id) {
+                // Server-to-client request: respond with null result.
+                // https://github.com/FurqanSoftware/codemirror-languageserver/issues/9
+                this.transport.send(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: data.id,
+                    result: null,
+                }));
+            }
             this.processNotification(data);
         });
-        const webSocketTransport = this.transport;
-        if (webSocketTransport && webSocketTransport.connection) {
-            // XXX(hjr265): Need a better way to do this. Relevant issue:
-            // https://github.com/FurqanSoftware/codemirror-languageserver/issues/9
-            webSocketTransport.connection.addEventListener('message', (message) => {
-                const data = JSON.parse(message.data);
-                if (data.method && data.id) {
-                    webSocketTransport.connection.send(JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: data.id,
-                        result: null,
-                    }));
-                }
-            });
-        }
         this.initializePromise = this.initialize();
     }
     getInitializeParams() {
@@ -135,6 +239,19 @@ class LanguageServerClient {
                         dynamicRegistration: true,
                         linkSupport: true,
                     },
+                    documentHighlight: {
+                        dynamicRegistration: true,
+                    },
+                    formatting: {
+                        dynamicRegistration: true,
+                    },
+                    rangeFormatting: {
+                        dynamicRegistration: true,
+                    },
+                    rename: {
+                        dynamicRegistration: true,
+                        prepareSupport: true,
+                    },
                 },
                 workspace: {
                     didChangeConfiguration: {
@@ -143,6 +260,7 @@ class LanguageServerClient {
                 },
             },
             initializationOptions: (_a = this.options.initializationOptions) !== null && _a !== void 0 ? _a : null,
+            locale: this.options.locale,
             processId: null,
             rootUri: this.rootUri,
             workspaceFolders: this.workspaceFolders,
@@ -178,6 +296,21 @@ class LanguageServerClient {
     async textDocumentTypeDefinition(params) {
         return await this.request('textDocument/typeDefinition', params, timeout);
     }
+    async textDocumentDocumentHighlight(params) {
+        return await this.request('textDocument/documentHighlight', params, timeout);
+    }
+    async textDocumentFormatting(params) {
+        return await this.request('textDocument/formatting', params, timeout);
+    }
+    async textDocumentRangeFormatting(params) {
+        return await this.request('textDocument/rangeFormatting', params, timeout);
+    }
+    async textDocumentPrepareRename(params) {
+        return await this.request('textDocument/prepareRename', params, timeout);
+    }
+    async textDocumentRename(params) {
+        return await this.request('textDocument/rename', params, timeout);
+    }
     async completionItemResolve(params) {
         return await this.request('completionItem/resolve', params, timeout);
     }
@@ -214,11 +347,14 @@ var SynchronizationMethod;
 class LanguageServerPlugin {
     constructor(view, { client, documentUri, languageId, allowHTMLContent, synchronizationMethod, }) {
         this.view = view;
+        this.changesTimeout = null;
+        this.pendingChanges = null;
         this.client = client;
         this.documentUri = documentUri;
         this.languageId = languageId;
         this.allowHTMLContent = allowHTMLContent;
-        this.synchronizationMethod = synchronizationMethod;
+        this.synchronizationMethod =
+            synchronizationMethod !== null && synchronizationMethod !== void 0 ? synchronizationMethod : SynchronizationMethod.Full;
         this.documentVersion = 0;
         this.client.attachPlugin(this);
         this.initialize({
@@ -229,20 +365,40 @@ class LanguageServerPlugin {
         if (!docChanged) {
             return;
         }
+        if (this.changesTimeout) {
+            clearTimeout(this.changesTimeout);
+        }
         switch (this.synchronizationMethod) {
             case SynchronizationMethod.Full:
-                this.sendChanges([
+                this.pendingChanges = [
                     {
                         text: this.view.state.doc.toString(),
                     },
-                ]);
+                ];
                 break;
             case SynchronizationMethod.Incremental:
-                this.sendChanges(changeSetToEvents(startState.doc, changes));
+                if (!this.pendingChanges) {
+                    this.pendingChanges = [];
+                }
+                this.pendingChanges.push(...changeSetToEvents(startState.doc, changes));
                 break;
         }
+        this.changesTimeout = setTimeout(() => {
+            this.changesTimeout = null;
+            if (this.pendingChanges) {
+                this.sendChanges(this.pendingChanges);
+                this.pendingChanges = null;
+            }
+        }, changesDelay);
     }
     destroy() {
+        if (this.changesTimeout) {
+            clearTimeout(this.changesTimeout);
+            if (this.pendingChanges) {
+                this.sendChanges(this.pendingChanges);
+                this.pendingChanges = null;
+            }
+        }
         this.client.detachPlugin(this);
     }
     async initialize({ documentText }) {
@@ -301,11 +457,12 @@ class LanguageServerPlugin {
         }
         const dom = document.createElement('div');
         dom.classList.add('documentation');
-        if (this.allowHTMLContent) {
-            dom.innerHTML = await formatContents(contents);
+        const formatted = await formatContents(contents);
+        if (formatted.isHTML || this.allowHTMLContent) {
+            dom.innerHTML = formatted.value;
         }
         else {
-            dom.textContent = await formatContents(contents);
+            dom.textContent = formatted.value;
         }
         return {
             pos,
@@ -365,56 +522,52 @@ class LanguageServerPlugin {
                 label,
                 detail,
                 apply(view, completion, from, to) {
+                    const changes = [];
                     if (isLSPTextEdit(textEdit)) {
-                        view.dispatch(insertCompletionText(view.state, textEdit.newText, posToOffset(view.state.doc, textEdit.range.start), posToOffset(view.state.doc, textEdit.range.end)));
+                        changes.push({
+                            from: posToOffset(view.state.doc, textEdit.range.start),
+                            to: Math.max(posToOffset(view.state.doc, textEdit.range.end), to),
+                            insert: textEdit.newText,
+                        });
                     }
                     else {
-                        view.dispatch(insertCompletionText(view.state, label, from, to));
-                    }
-                    if (!additionalTextEdits) {
-                        return;
+                        changes.push({
+                            from,
+                            to,
+                            insert: label,
+                        });
                     }
-                    additionalTextEdits
-                        .sort(({ range: { end: a } }, { range: { end: b } }) => {
-                        if (posToOffset(view.state.doc, a) <
-                            posToOffset(view.state.doc, b)) {
-                            return 1;
+                    if (additionalTextEdits) {
+                        for (const edit of additionalTextEdits) {
+                            changes.push({
+                                from: posToOffset(view.state.doc, edit.range.start),
+                                to: posToOffset(view.state.doc, edit.range.end),
+                                insert: edit.newText,
+                            });
                         }
-                        else if (posToOffset(view.state.doc, a) >
-                            posToOffset(view.state.doc, b)) {
-                            return -1;
-                        }
-                        return 0;
-                    })
-                        .forEach((textEdit) => {
-                        view.dispatch(view.state.update({
-                            changes: {
-                                from: posToOffset(view.state.doc, textEdit.range.start),
-                                to: posToOffset(view.state.doc, textEdit.range.end),
-                                insert: textEdit.newText,
-                            },
-                        }));
-                    });
+                    }
+                    view.dispatch(view.state.update({ changes }));
                 },
                 type: kind && CompletionItemKindMap[kind].toLowerCase(),
             };
             completion.info = async () => {
                 var _a;
-                let { documentation } = item;
-                if (!documentation &&
+                if (!item.documentation &&
                     ((_a = this.client.capabilities.completionProvider) === null || _a === void 0 ? void 0 : _a.resolveProvider)) {
                     const resolvedItem = await this.client.completionItemResolve(item);
-                    documentation = resolvedItem.documentation;
+                    item.documentation = resolvedItem.documentation;
                 }
+                const { documentation } = item;
                 if (!documentation)
                     return null;
                 const dom = document.createElement('div');
                 dom.classList.add('documentation');
-                if (this.allowHTMLContent) {
-                    dom.innerHTML = await formatContents(documentation);
+                const formatted = await formatContents(documentation);
+                if (formatted.isHTML || this.allowHTMLContent) {
+                    dom.innerHTML = formatted.value;
                 }
                 else {
-                    dom.textContent = await formatContents(documentation);
+                    dom.textContent = formatted.value;
                 }
                 return dom;
             };
@@ -510,19 +663,32 @@ class LanguageServerPlugin {
 const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
-        let value = contents.value;
         if (contents.kind === 'markdown') {
-            value = await marked.parse(value);
+            return {
+                value: await marked.parse(contents.value),
+                isHTML: true,
+            };
         }
-        return value;
+        return { value: contents.value, isHTML: false };
     }
     else if (Array.isArray(contents)) {
-        return contents.map((c) => formatContents(c) + '\n\n').join('');
+        const parts = await Promise.all(contents.map((c) => formatContents(c)));
+        const isHTML = parts.some((p) => p.isHTML);
+        const value = parts
+            .map((p) => (isHTML && !p.isHTML ? escapeHTML(p.value) : p.value))
+            .join(isHTML ? '<br><br>' : '\n\n');
+        return { value, isHTML };
     }
     else if (typeof contents === 'string') {
-        return contents;
+        return { value: contents, isHTML: false };
     }
 }
+function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
 function toSet(chars) {
     let preamble = '';
     let flat = Array.from(chars).join('');
@@ -578,6 +744,223 @@ const jumpToDefinitionKeymap = [
     { key: 'Mod-F12', run: jumpToTypeDefinition, preventDefault: true },
 ];
 
+const formattingOptions = Facet.define({
+    combine(values) {
+        return Object.assign({ tabSize: 4, insertSpaces: true }, ...values);
+    },
+});
+function getFormattingOptions(view) {
+    var _a;
+    const opts = view.state.facet(formattingOptions);
+    return {
+        ...opts,
+        tabSize: (_a = opts.tabSize) !== null && _a !== void 0 ? _a : view.state.tabSize,
+    };
+}
+function applyTextEdits(view, edits) {
+    const changes = edits.map((edit) => ({
+        from: posToOffset(view.state.doc, edit.range.start),
+        to: posToOffset(view.state.doc, edit.range.end),
+        insert: edit.newText,
+    }));
+    view.dispatch(view.state.update({ changes }));
+}
+function formatDocument(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentFormattingProvider)) {
+        return false;
+    }
+    plugin.client
+        .textDocumentFormatting({
+        textDocument: { uri: plugin.documentUri },
+        options: getFormattingOptions(view),
+    })
+        .then((edits) => {
+        if (edits && edits.length > 0) {
+            applyTextEdits(view, edits);
+        }
+    });
+    return true;
+}
+function formatSelection(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentRangeFormattingProvider)) {
+        return false;
+    }
+    const { from, to } = view.state.selection.main;
+    plugin.client
+        .textDocumentRangeFormatting({
+        textDocument: { uri: plugin.documentUri },
+        range: {
+            start: offsetToPos(view.state.doc, from),
+            end: offsetToPos(view.state.doc, to),
+        },
+        options: getFormattingOptions(view),
+    })
+        .then((edits) => {
+        if (edits && edits.length > 0) {
+            applyTextEdits(view, edits);
+        }
+    });
+    return true;
+}
+
+const openRenamePanel = StateEffect.define();
+const closeRenamePanel = StateEffect.define();
+const renamePanelState = StateField.define({
+    create() {
+        return null;
+    },
+    update(value, tr) {
+        for (const effect of tr.effects) {
+            if (effect.is(openRenamePanel))
+                return effect.value;
+            if (effect.is(closeRenamePanel))
+                return null;
+        }
+        return value;
+    },
+    provide: (field) => showPanel.from(field, (value) => value != null ? (view) => createRenamePanel(view, value) : null),
+});
+function applyWorkspaceEdit(view, edit) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return;
+    const changes = [];
+    if (edit.changes) {
+        const edits = edit.changes[plugin.documentUri];
+        if (edits) {
+            for (const e of edits) {
+                changes.push({
+                    from: posToOffset(view.state.doc, e.range.start),
+                    to: posToOffset(view.state.doc, e.range.end),
+                    insert: e.newText,
+                });
+            }
+        }
+    }
+    if (edit.documentChanges) {
+        for (const change of edit.documentChanges) {
+            if ('textDocument' in change) {
+                if (change.textDocument.uri !== plugin.documentUri)
+                    continue;
+                for (const e of change.edits) {
+                    if ('range' in e) {
+                        changes.push({
+                            from: posToOffset(view.state.doc, e.range.start),
+                            to: posToOffset(view.state.doc, e.range.end),
+                            insert: e.newText,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (changes.length > 0) {
+        view.dispatch(view.state.update({ changes }));
+    }
+}
+function createRenamePanel(view, placeholder) {
+    const dom = document.createElement('div');
+    dom.className = 'cm-lsp-rename-panel';
+    const input = document.createElement('input');
+    input.className = 'cm-lsp-rename-input';
+    input.value = placeholder;
+    input.setAttribute('aria-label', 'New name');
+    const submit = () => {
+        const newName = input.value.trim();
+        if (!newName || newName === placeholder) {
+            view.dispatch({ effects: closeRenamePanel.of(null) });
+            view.focus();
+            return;
+        }
+        performRename(view, newName);
+    };
+    input.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            submit();
+        }
+        else if (e.key === 'Escape') {
+            e.preventDefault();
+            view.dispatch({ effects: closeRenamePanel.of(null) });
+            view.focus();
+        }
+    });
+    dom.appendChild(input);
+    return {
+        dom,
+        top: true,
+        mount() {
+            input.select();
+        },
+    };
+}
+async function performRename(view, newName) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return;
+    const pos = view.state.selection.main.head;
+    view.dispatch({ effects: closeRenamePanel.of(null) });
+    view.focus();
+    const result = await plugin.client.textDocumentRename({
+        textDocument: { uri: plugin.documentUri },
+        position: offsetToPos(view.state.doc, pos),
+        newName,
+    });
+    if (result) {
+        applyWorkspaceEdit(view, result);
+    }
+}
+function renameSymbol(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.renameProvider)) {
+        return false;
+    }
+    const pos = view.state.selection.main.head;
+    const capabilities = plugin.client.capabilities;
+    const renameProvider = capabilities.renameProvider;
+    const supportsPrepare = typeof renameProvider === 'object' && renameProvider.prepareProvider;
+    if (supportsPrepare) {
+        plugin.client
+            .textDocumentPrepareRename({
+            textDocument: { uri: plugin.documentUri },
+            position: offsetToPos(view.state.doc, pos),
+        })
+            .then((result) => {
+            if (!result)
+                return;
+            const placeholder = 'placeholder' in result
+                ? result.placeholder
+                : view.state.doc.sliceString(posToOffset(view.state.doc, result.start), posToOffset(view.state.doc, result.end));
+            view.dispatch({
+                effects: openRenamePanel.of(placeholder),
+            });
+        });
+    }
+    else {
+        const word = view.state.wordAt(pos);
+        const placeholder = word
+            ? view.state.doc.sliceString(word.from, word.to)
+            : '';
+        view.dispatch({ effects: openRenamePanel.of(placeholder) });
+    }
+    return true;
+}
+const renameExtension = () => renamePanelState;
+
 const hoverTooltip = () => hoverTooltip$1((view, pos) => {
     var _a;
     const plugin = view.plugin(languageServerPlugin);
@@ -600,7 +983,8 @@ const autocompletion = () => autocompletion$1({
                 trigKind = CompletionTriggerKind.TriggerCharacter;
                 trigChar = line.text[pos - line.from - 1];
             }
-            if (trigKind === CompletionTriggerKind.Invoked &&
+            if (!explicit &&
+                trigKind === CompletionTriggerKind.Invoked &&
                 !context.matchBefore(/\w+$/)) {
                 return null;
             }
@@ -612,6 +996,103 @@ const autocompletion = () => autocompletion$1({
     ],
 });
 
+const highlightField = StateField.define({
+    create() {
+        return Decoration.none;
+    },
+    update(decorations, tr) {
+        for (const effect of tr.effects) {
+            if (effect.is(setHighlightsEffect)) {
+                return effect.value;
+            }
+        }
+        if (tr.docChanged) {
+            return Decoration.none;
+        }
+        return decorations;
+    },
+    provide: (field) => EditorView.decorations.from(field),
+});
+const setHighlightsEffect = StateEffect.define();
+const textDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-text',
+});
+const readDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-read',
+});
+const writeDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-write',
+});
+function decorationForKind(kind) {
+    switch (kind) {
+        case DocumentHighlightKind.Read:
+            return readDecoration;
+        case DocumentHighlightKind.Write:
+            return writeDecoration;
+        default:
+            return textDecoration;
+    }
+}
+const highlightPlugin = ViewPlugin.fromClass(class {
+    constructor() {
+        this.pending = -1;
+    }
+    update(update) {
+        if (!update.selectionSet && !update.docChanged) {
+            return;
+        }
+        if (update.docChanged) {
+            return;
+        }
+        clearTimeout(this.pending);
+        this.pending = setTimeout(() => this.requestHighlights(update.view), 100);
+    }
+    async requestHighlights(view) {
+        var _a;
+        const plugin = view.plugin(languageServerPlugin);
+        if (!plugin)
+            return;
+        const { state } = view;
+        const pos = state.selection.main.head;
+        if (!plugin.client.ready ||
+            !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentHighlightProvider)) {
+            view.dispatch({ effects: setHighlightsEffect.of(Decoration.none) });
+            return;
+        }
+        const result = await plugin.client.textDocumentDocumentHighlight({
+            textDocument: { uri: plugin.documentUri },
+            position: offsetToPos(state.doc, pos),
+        });
+        if (view.state.selection.main.head !== pos) {
+            return;
+        }
+        if (!result || result.length === 0) {
+            view.dispatch({ effects: setHighlightsEffect.of(Decoration.none) });
+            return;
+        }
+        const decorations = result
+            .map((highlight) => {
+            const from = posToOffset(view.state.doc, highlight.range.start);
+            const to = posToOffset(view.state.doc, highlight.range.end);
+            if (from == null || to == null)
+                return null;
+            return decorationForKind(highlight.kind).range(from, to);
+        })
+            .filter((d) => d != null)
+            .sort((a, b) => a.from - b.from);
+        view.dispatch({
+            effects: setHighlightsEffect.of(Decoration.set(decorations)),
+        });
+    }
+    destroy() {
+        clearTimeout(this.pending);
+    }
+});
+const documentHighlight = () => [
+    highlightField,
+    highlightPlugin,
+];
+
 const mouseHandler = () => EditorView.domEventHandlers({
     mousedown: (event, view) => {
         if (!event.ctrlKey && !event.metaKey)
@@ -651,9 +1132,11 @@ function languageServerWithTransport(options) {
         }),
         hoverTooltip(),
         autocompletion(),
+        documentHighlight(),
+        renameExtension(),
         keymap.of([...jumpToDefinitionKeymap]),
         mouseHandler(),
     ];
 }
 
-export { LanguageServerClient, SynchronizationMethod, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };
+export { LanguageServerClient, SynchronizationMethod, WebSocketTransport, formatDocument, formatSelection, formattingOptions, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport, renameSymbol };

package/dist/jsonrpc.d.ts

@@ -0,0 +1,34 @@
+export interface Transport {
+    send(message: string): void;
+    onMessage(callback: (message: string) => void): void;
+    onClose(callback: () => void): void;
+    onError(callback: (error: Error) => void): void;
+    close(): void;
+}
+export declare class WebSocketTransport implements Transport {
+    connection: WebSocket;
+    constructor(uri: string);
+    send(message: string): void;
+    onMessage(callback: (message: string) => void): void;
+    onClose(callback: () => void): void;
+    onError(callback: (error: Error) => void): void;
+    close(): void;
+}
+export declare class JSONRPCClient {
+    private transport;
+    private nextId;
+    private pending;
+    private notificationHandlers;
+    private ready;
+    constructor(transport: Transport);
+    request(req: {
+        method: string;
+        params: any;
+    }, timeout: number): Promise<any>;
+    notify(notification: {
+        method: string;
+        params: any;
+    }): Promise<void>;
+    onNotification(handler: (data: any) => void): void;
+    close(): void;
+}

package/dist/plugin.d.ts

@@ -1,8 +1,8 @@
 import { EditorView, Tooltip, ViewPlugin } from '@codemirror/view';
+import type { Transport } from './jsonrpc';
 import { CompletionTriggerKind } from 'vscode-languageserver-protocol';
 import type { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
 import type { PluginValue, ViewUpdate } from '@codemirror/view';
-import { Transport } from '@open-rpc/client-js/build/transports/Transport';
 import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol';
 import type * as LSP from 'vscode-languageserver-protocol';
 interface LSPRequestMap {
@@ -24,6 +24,26 @@ interface LSPRequestMap {
         LSP.TypeDefinitionParams,
         LSP.Location | LSP.Location[] | LSP.LocationLink[] | null
     ];
+    'textDocument/documentHighlight': [
+        LSP.DocumentHighlightParams,
+        LSP.DocumentHighlight[] | null
+    ];
+    'textDocument/formatting': [
+        LSP.DocumentFormattingParams,
+        LSP.TextEdit[] | null
+    ];
+    'textDocument/rangeFormatting': [
+        LSP.DocumentRangeFormattingParams,
+        LSP.TextEdit[] | null
+    ];
+    'textDocument/prepareRename': [
+        LSP.PrepareRenameParams,
+        LSP.Range | {
+            range: LSP.Range;
+            placeholder: string;
+        } | null
+    ];
+    'textDocument/rename': [LSP.RenameParams, LSP.WorkspaceEdit | null];
     'completionItem/resolve': [LSP.CompletionItem, LSP.CompletionItem];
 }
 interface LSPNotifyMap {
@@ -55,7 +75,6 @@ export declare class LanguageServerClient<InitializationOptions = unknown> {
     private workspaceFolders;
     private autoClose?;
     private transport;
-    private requestManager;
     private client;
     private plugins;
     private options;
@@ -63,18 +82,26 @@ export declare class LanguageServerClient<InitializationOptions = unknown> {
     protected getInitializeParams(): LSP.InitializeParams;
     initialize(): Promise<void>;
     close(): void;
-    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<LSP.DidOpenTextDocumentParams>;
-    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<LSP.DidChangeTextDocumentParams>;
+    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<void>;
+    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<void>;
     textDocumentHover(params: LSP.HoverParams): Promise<LSP.Hover>;
     textDocumentCompletion(params: LSP.CompletionParams): Promise<LSP.CompletionList | LSP.CompletionItem[]>;
     textDocumentDefinition(params: LSP.DefinitionParams): Promise<LSP.Location | LSP.Location[] | LSP.LocationLink[]>;
     textDocumentDeclaration(params: LSP.DeclarationParams): Promise<LSP.Location | LSP.Location[] | LSP.LocationLink[]>;
     textDocumentTypeDefinition(params: LSP.TypeDefinitionParams): Promise<LSP.Location | LSP.Location[] | LSP.LocationLink[]>;
+    textDocumentDocumentHighlight(params: LSP.DocumentHighlightParams): Promise<LSP.DocumentHighlight[]>;
+    textDocumentFormatting(params: LSP.DocumentFormattingParams): Promise<LSP.TextEdit[]>;
+    textDocumentRangeFormatting(params: LSP.DocumentRangeFormattingParams): Promise<LSP.TextEdit[]>;
+    textDocumentPrepareRename(params: LSP.PrepareRenameParams): Promise<LSP.Range | {
+        range: LSP.Range;
+        placeholder: string;
+    }>;
+    textDocumentRename(params: LSP.RenameParams): Promise<LSP.WorkspaceEdit>;
     completionItemResolve(params: LSP.CompletionItem): Promise<LSP.CompletionItem>;
     attachPlugin(plugin: LanguageServerPlugin): void;
     detachPlugin(plugin: LanguageServerPlugin): void;
     protected request<K extends keyof LSPRequestMap>(method: K, params: LSPRequestMap[K][0], timeout: number): Promise<LSPRequestMap[K][1]>;
-    protected notify<K extends keyof LSPNotifyMap>(method: K, params: LSPNotifyMap[K]): Promise<LSPNotifyMap[K]>;
+    protected notify<K extends keyof LSPNotifyMap>(method: K, params: LSPNotifyMap[K]): Promise<void>;
     protected processNotification(notification: Notification): void;
 }
 export declare enum SynchronizationMethod {
@@ -84,11 +111,13 @@ export declare enum SynchronizationMethod {
 export declare class LanguageServerPlugin implements PluginValue {
     private view;
     client: LanguageServerClient;
-    private documentUri;
+    documentUri: string;
     private languageId;
     private documentVersion;
     private allowHTMLContent;
     private synchronizationMethod;
+    private changesTimeout;
+    private pendingChanges;
     constructor(view: EditorView, { client, documentUri, languageId, allowHTMLContent, synchronizationMethod, }: {
         client: LanguageServerClient;
         documentUri: string;
@@ -162,5 +191,6 @@ export interface LanguageServerClientOptions<InitializationOptions = unknown> ex
     transport: Transport;
     autoClose?: boolean;
     initializationOptions?: InitializationOptions;
+    locale?: string;
 }
 export {};

package/dist/rename.d.ts

@@ -0,0 +1,4 @@
+import { StateField } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+export declare function renameSymbol(view: EditorView): boolean;
+export declare const renameExtension: () => StateField<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "codemirror-languageserver",
-    "version": "1.18.0",
+    "version": "1.19.0",
     "description": "Language Server Plugin for CodeMirror 6",
     "main": "dist/index.js",
     "type": "module",
@@ -40,13 +40,14 @@
         "typescript": "^5.9.2"
     },
     "dependencies": {
+        "marked": "^16.1.2",
+        "vscode-languageserver-protocol": "^3.17.5"
+    },
+    "peerDependencies": {
         "@codemirror/autocomplete": "^6.18.6",
         "@codemirror/lint": "^6.8.5",
         "@codemirror/state": "^6.5.2",
-        "@codemirror/view": "^6.38.1",
-        "@open-rpc/client-js": "^1.8.1",
-        "marked": "^16.1.2",
-        "vscode-languageserver-protocol": "^3.17.5"
+        "@codemirror/view": "^6.38.1"
     },
     "prettier": {
         "tabWidth": 4,