codemirror-languageserver 1.13.0 → 1.15.0

package/demo/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html>
+    <head>
+        <title>CodeMirror Language Server Demo</title>
+        <link
+            type="text/css"
+            rel="stylesheet"
+            href="https://cdn.jsdelivr.net/gh/FurqanSoftware/sleek@v1.52.4/dist/sleek.css"
+        />
+    </head>
+    <body class="p-1">
+        <div class="form__field br-1-4">
+            <div id="editor"></div>
+        </div>
+        <script type="module" src="./dist/demo.js"></script>
+    </body>
+</html>

package/dist/definition.d.ts

@@ -0,0 +1,4 @@
+import { Command, KeyBinding } from '@codemirror/view';
+export declare const jumpToDefinition: Command;
+export declare const jumpToDefinitionPos: (pos: number) => Command;
+export declare const jumpToDefinitionKeymap: readonly KeyBinding[];

package/dist/index.d.ts

@@ -1,98 +1,2 @@
-import { EditorView, Tooltip } from "@codemirror/view";
-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 LSPEventMap {
-    "textDocument/publishDiagnostics": LSP.PublishDiagnosticsParams;
-}
-type Notification = {
-    [key in keyof LSPEventMap]: {
-        jsonrpc: "2.0";
-        id?: null | undefined;
-        method: key;
-        params: LSPEventMap[key];
-    };
-}[keyof LSPEventMap];
-export declare class LanguageServerClient {
-    ready: boolean;
-    capabilities: LSP.ServerCapabilities<any>;
-    initializePromise: Promise<void>;
-    private rootUri;
-    private workspaceFolders;
-    private autoClose?;
-    private transport;
-    private requestManager;
-    private client;
-    private plugins;
-    constructor(options: LanguageServerClientOptions);
-    initialize(): Promise<void>;
-    close(): void;
-    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<LSP.DidOpenTextDocumentParams>;
-    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<LSP.DidChangeTextDocumentParams>;
-    textDocumentHover(params: LSP.HoverParams): Promise<LSP.Hover>;
-    textDocumentCompletion(params: LSP.CompletionParams): Promise<LSP.CompletionList | LSP.CompletionItem[]>;
-    attachPlugin(plugin: LanguageServerPlugin): void;
-    detachPlugin(plugin: LanguageServerPlugin): void;
-    private request;
-    private notify;
-    private processNotification;
-}
-declare class LanguageServerPlugin implements PluginValue {
-    private view;
-    private allowHTMLContent;
-    client: LanguageServerClient;
-    private documentUri;
-    private languageId;
-    private documentVersion;
-    private changesTimeout;
-    constructor(view: EditorView, allowHTMLContent: boolean);
-    update({ docChanged }: ViewUpdate): void;
-    destroy(): void;
-    initialize({ documentText }: {
-        documentText: string;
-    }): Promise<void>;
-    sendChange({ documentText }: {
-        documentText: string;
-    }): Promise<void>;
-    requestDiagnostics(view: EditorView): void;
-    requestHoverTooltip(view: EditorView, { line, character }: {
-        line: number;
-        character: number;
-    }): Promise<Tooltip | null>;
-    requestCompletion(context: CompletionContext, { line, character }: {
-        line: number;
-        character: number;
-    }, { triggerKind, triggerCharacter, }: {
-        triggerKind: CompletionTriggerKind;
-        triggerCharacter: string | undefined;
-    }): Promise<CompletionResult | null>;
-    processNotification(notification: Notification): void;
-    processDiagnostics(params: PublishDiagnosticsParams): void;
-}
-interface LanguageServerBaseOptions {
-    rootUri: string | null;
-    workspaceFolders: LSP.WorkspaceFolder[] | null;
-    documentUri: string;
-    languageId: string;
-}
-interface LanguageServerClientOptions extends LanguageServerBaseOptions {
-    transport: Transport;
-    autoClose?: boolean;
-}
-interface LanguageServerOptions extends LanguageServerClientOptions {
-    client?: LanguageServerClient;
-    allowHTMLContent?: boolean;
-}
-interface LanguageServerWebsocketOptions extends LanguageServerBaseOptions {
-    serverUri: `ws://${string}` | `wss://${string}`;
-}
-export declare function languageServer(options: LanguageServerWebsocketOptions): ({
-    extension: import("@codemirror/state").Extension;
-} | readonly import("@codemirror/state").Extension[])[];
-export declare function languageServerWithTransport(options: LanguageServerOptions): ({
-    extension: import("@codemirror/state").Extension;
-} | readonly import("@codemirror/state").Extension[])[];
-export {};
+export { LanguageServerClient, languageServerPlugin, languageServer, languageServerWithTransport, } from './plugin';
+export { jumpToDefinition, jumpToDefinitionPos, jumpToDefinitionKeymap, } from './definition';

package/dist/index.js

@@ -1,20 +1,41 @@
-import { autocompletion, insertCompletionText } from '@codemirror/autocomplete';
+import { insertCompletionText, autocompletion } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
 import { Facet } from '@codemirror/state';
 import { ViewPlugin, hoverTooltip } from '@codemirror/view';
 import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
-import { CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity } from 'vscode-languageserver-protocol';
-import { marked } from 'marked/lib/marked.esm.js';
+import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind } from 'vscode-languageserver-protocol';
+import { marked } from 'marked';
+
+function posToOffset(doc, pos) {
+    if (pos.line >= doc.lines) {
+        return;
+    }
+    const offset = doc.line(pos.line + 1).from + pos.character;
+    if (offset > doc.length) {
+        return;
+    }
+    return offset;
+}
+function offsetToPos(doc, offset) {
+    const line = doc.lineAt(offset);
+    return {
+        character: offset - line.from,
+        line: line.number - 1,
+    };
+}
 
 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, "");
-const client = Facet.define({ combine: useLast });
+const useLast = (values) => values.reduce((_, v) => v, '');
+const client = Facet.define({
+    combine: useLast,
+});
 const documentUri = Facet.define({ combine: useLast });
 const languageId = Facet.define({ combine: useLast });
 class LanguageServerClient {
     constructor(options) {
+        this.options = options;
         this.rootUri = options.rootUri;
         this.workspaceFolders = options.workspaceFolders;
         this.autoClose = options.autoClose;
@@ -29,11 +50,11 @@ class LanguageServerClient {
         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) => {
+            webSocketTransport.connection.addEventListener('message', (message) => {
                 const data = JSON.parse(message.data);
                 if (data.method && data.id) {
                     webSocketTransport.connection.send(JSON.stringify({
-                        jsonrpc: "2.0",
+                        jsonrpc: '2.0',
                         id: data.id,
                         result: null,
                     }));
@@ -42,13 +63,14 @@ class LanguageServerClient {
         }
         this.initializePromise = this.initialize();
     }
-    async initialize() {
-        const { capabilities } = await this.request("initialize", {
+    getInitializeParams() {
+        var _a;
+        return {
             capabilities: {
                 textDocument: {
                     hover: {
                         dynamicRegistration: true,
-                        contentFormat: ["plaintext", "markdown"],
+                        contentFormat: ['plaintext', 'markdown'],
                     },
                     moniker: {},
                     synchronization: {
@@ -62,16 +84,16 @@ class LanguageServerClient {
                         completionItem: {
                             snippetSupport: false,
                             commitCharactersSupport: true,
-                            documentationFormat: ["plaintext", "markdown"],
+                            documentationFormat: ['plaintext', 'markdown'],
                             deprecatedSupport: false,
                             preselectSupport: false,
                         },
-                        contextSupport: false,
+                        contextSupport: true,
                     },
                     signatureHelp: {
                         dynamicRegistration: true,
                         signatureInformation: {
-                            documentationFormat: ["plaintext", "markdown"],
+                            documentationFormat: ['plaintext', 'markdown'],
                         },
                     },
                     declaration: {
@@ -97,29 +119,35 @@ class LanguageServerClient {
                     },
                 },
             },
-            initializationOptions: null,
+            initializationOptions: (_a = this.options.initializationOptions) !== null && _a !== void 0 ? _a : null,
             processId: null,
             rootUri: this.rootUri,
             workspaceFolders: this.workspaceFolders,
-        }, timeout * 3);
+        };
+    }
+    async initialize() {
+        const { capabilities } = await this.request('initialize', this.getInitializeParams(), timeout * 3);
         this.capabilities = capabilities;
-        this.notify("initialized", {});
+        this.notify('initialized', {});
         this.ready = true;
     }
     close() {
         this.client.close();
     }
     textDocumentDidOpen(params) {
-        return this.notify("textDocument/didOpen", params);
+        return this.notify('textDocument/didOpen', params);
     }
     textDocumentDidChange(params) {
-        return this.notify("textDocument/didChange", params);
+        return this.notify('textDocument/didChange', params);
     }
     async textDocumentHover(params) {
-        return await this.request("textDocument/hover", params, timeout);
+        return await this.request('textDocument/hover', params, timeout);
     }
     async textDocumentCompletion(params) {
-        return await this.request("textDocument/completion", params, timeout);
+        return await this.request('textDocument/completion', params, timeout);
+    }
+    async textDocumentDefinition(params) {
+        return await this.request('textDocument/definition', params, timeout);
     }
     attachPlugin(plugin) {
         this.plugins.push(plugin);
@@ -231,13 +259,13 @@ class LanguageServerPlugin {
         if (pos === null) {
             return null;
         }
-        const dom = document.createElement("div");
-        dom.classList.add("documentation");
+        const dom = document.createElement('div');
+        dom.classList.add('documentation');
         if (this.allowHTMLContent) {
-            dom.innerHTML = formatContents(contents);
+            dom.innerHTML = await formatContents(contents);
         }
         else {
-            dom.textContent = formatContents(contents);
+            dom.textContent = await formatContents(contents);
         }
         return {
             pos,
@@ -247,7 +275,8 @@ class LanguageServerPlugin {
         };
     }
     async requestCompletion(context, { line, character }, { triggerKind, triggerCharacter, }) {
-        if (!this.client.ready || !this.client.capabilities.completionProvider) {
+        if (!this.client.ready ||
+            !this.client.capabilities.completionProvider) {
             return null;
         }
         this.sendChange({
@@ -264,7 +293,7 @@ class LanguageServerPlugin {
         if (!result) {
             return null;
         }
-        let items = "items" in result ? result.items : result;
+        let items = 'items' in result ? result.items : result;
         const [span, match] = prefixMatch(items);
         const token = context.matchBefore(match);
         let { pos } = context;
@@ -309,10 +338,12 @@ class LanguageServerPlugin {
                     }
                     additionalTextEdits
                         .sort(({ range: { end: a } }, { range: { end: b } }) => {
-                        if (posToOffset(view.state.doc, a) < posToOffset(view.state.doc, b)) {
+                        if (posToOffset(view.state.doc, a) <
+                            posToOffset(view.state.doc, b)) {
                             return 1;
                         }
-                        else if (posToOffset(view.state.doc, a) > posToOffset(view.state.doc, b)) {
+                        else if (posToOffset(view.state.doc, a) >
+                            posToOffset(view.state.doc, b)) {
                             return -1;
                         }
                         return 0;
@@ -330,7 +361,18 @@ class LanguageServerPlugin {
                 type: kind && CompletionItemKindMap[kind].toLowerCase(),
             };
             if (documentation) {
-                completion.info = formatContents(documentation);
+                completion.info = async () => {
+                    const dom = document.createElement('div');
+                    dom.classList.add('documentation');
+                    if (this.allowHTMLContent) {
+                        dom.innerHTML = await formatContents(documentation);
+                    }
+                    else {
+                        dom.textContent =
+                            await formatContents(documentation);
+                    }
+                    return dom;
+                };
             }
             return completion;
         });
@@ -340,10 +382,39 @@ class LanguageServerPlugin {
             filter: false,
         };
     }
+    async requestDefinition(view, { line, character }) {
+        if (!this.client.ready ||
+            !this.client.capabilities.definitionProvider) {
+            return null;
+        }
+        const result = await this.client.textDocumentDefinition({
+            textDocument: { uri: this.documentUri },
+            position: { line, character },
+        });
+        if (!result)
+            return;
+        const location = Array.isArray(result) ? result[0] : result;
+        const uri = location.uri ||
+            location.targetUri;
+        const range = location.range ||
+            location.targetRange;
+        if (uri === this.documentUri) {
+            view.dispatch(view.state.update({
+                selection: {
+                    anchor: posToOffset(view.state.doc, range.start),
+                    head: posToOffset(view.state.doc, range.end),
+                },
+            }));
+        }
+        return {
+            uri,
+            range,
+        };
+    }
     processNotification(notification) {
         try {
             switch (notification.method) {
-                case "textDocument/publishDiagnostics":
+                case 'textDocument/publishDiagnostics':
                     this.processDiagnostics(notification.params);
             }
         }
@@ -360,14 +431,17 @@ class LanguageServerPlugin {
             from: posToOffset(this.view.state.doc, range.start),
             to: posToOffset(this.view.state.doc, range.end),
             severity: {
-                [DiagnosticSeverity.Error]: "error",
-                [DiagnosticSeverity.Warning]: "warning",
-                [DiagnosticSeverity.Information]: "info",
-                [DiagnosticSeverity.Hint]: "info",
+                [DiagnosticSeverity.Error]: 'error',
+                [DiagnosticSeverity.Warning]: 'warning',
+                [DiagnosticSeverity.Information]: 'info',
+                [DiagnosticSeverity.Hint]: 'info',
             }[severity],
             message,
         }))
-            .filter(({ from, to }) => from !== null && to !== null && from !== undefined && to !== undefined)
+            .filter(({ from, to }) => from !== null &&
+            to !== null &&
+            from !== undefined &&
+            to !== undefined)
             .sort((a, b) => {
             switch (true) {
                 case a.from < b.from:
@@ -380,33 +454,38 @@ class LanguageServerPlugin {
         this.view.dispatch(setDiagnostics(this.view.state, diagnostics));
     }
 }
+const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 function languageServer(options) {
     const serverUri = options.serverUri;
-    delete options.serverUri;
+    const { serverUri: _, ...optionsWithoutServerUri } = options;
     return languageServerWithTransport({
-        ...options,
+        ...optionsWithoutServerUri,
         transport: new WebSocketTransport(serverUri),
     });
 }
 function languageServerWithTransport(options) {
-    let plugin = null;
     return [
-        client.of(options.client || new LanguageServerClient({ ...options, autoClose: true })),
+        client.of(options.client ||
+            new LanguageServerClient({
+                ...options,
+                autoClose: true,
+            })),
         documentUri.of(options.documentUri),
         languageId.of(options.languageId),
-        ViewPlugin.define((view) => (plugin = new LanguageServerPlugin(view, options.allowHTMLContent))),
+        languageServerPlugin.of(options.allowHTMLContent),
         hoverTooltip((view, pos) => {
             var _a;
-            return (_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null;
+            const plugin = view.plugin(languageServerPlugin);
+            return ((_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null);
         }),
         autocompletion({
             override: [
                 async (context) => {
                     var _a, _b, _c;
-                    if (plugin == null) {
+                    const { state, pos, explicit, view } = context;
+                    const plugin = view.plugin(languageServerPlugin);
+                    if (plugin == null)
                         return null;
-                    }
-                    const { state, pos, explicit } = context;
                     const line = state.doc.lineAt(pos);
                     let trigKind = CompletionTriggerKind.Invoked;
                     let trigChar;
@@ -428,61 +507,45 @@ function languageServerWithTransport(options) {
         }),
     ];
 }
-function posToOffset(doc, pos) {
-    if (pos.line >= doc.lines) {
-        return;
-    }
-    const offset = doc.line(pos.line + 1).from + pos.character;
-    if (offset > doc.length) {
-        return;
-    }
-    return offset;
-}
-function offsetToPos(doc, offset) {
-    const line = doc.lineAt(offset);
-    return {
-        character: offset - line.from,
-        line: line.number - 1,
-    };
-}
-function formatContents(contents) {
+async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
         let value = contents.value;
-        if (contents.kind === "markdown") {
-            value = marked.parse(value);
+        if (contents.kind === 'markdown') {
+            value = await marked.parse(value);
         }
         return value;
     }
     else if (Array.isArray(contents)) {
-        return contents.map((c) => formatContents(c) + "\n\n").join("");
+        return contents.map((c) => formatContents(c) + '\n\n').join('');
     }
-    else if (typeof contents === "string") {
+    else if (typeof contents === 'string') {
         return contents;
     }
 }
 function toSet(chars) {
-    let preamble = "";
-    let flat = Array.from(chars).join("");
+    let preamble = '';
+    let flat = Array.from(chars).join('');
     const words = /\w/.test(flat);
     if (words) {
-        preamble += "\\w";
-        flat = flat.replace(/\w/g, "");
+        preamble += '\\w';
+        flat = flat.replace(/\w/g, '');
     }
-    return `[${preamble}${flat.replace(/[^\w\s]/g, "\\$&")}]`;
+    return `[${preamble}${flat.replace(/[^\w\s]/g, '\\$&')}]`;
 }
 function prefixMatch(items) {
     var _a;
     const first = new Set();
     const rest = new Set();
     for (const item of items) {
-        const [initial, ...restStr] = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const text = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const initial = text[0];
         first.add(initial);
-        for (const char of restStr) {
-            rest.add(char);
+        for (let i = 1; i < text.length; i++) {
+            rest.add(text[i]);
         }
     }
-    const source = toSet(first) + toSet(rest) + "*$";
-    return [new RegExp("^" + source), new RegExp(source)];
+    const source = toSet(first) + toSet(rest) + '*$';
+    return [new RegExp('^' + source), new RegExp(source)];
 }
 function isLSPTextEdit(textEdit) {
     return (textEdit === null || textEdit === void 0 ? void 0 : textEdit.range) !== undefined;
@@ -491,4 +554,17 @@ function isLSPMarkupContent(contents) {
     return contents.kind !== undefined;
 }
 
-export { LanguageServerClient, languageServer, languageServerWithTransport };
+function jumpTo(view, pos) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    plugin.requestDefinition(view, offsetToPos(view.state.doc, pos));
+    return true;
+}
+const jumpToDefinition = (view) => jumpTo(view, view.state.selection.main.head);
+const jumpToDefinitionPos = (pos) => (view) => jumpTo(view, pos);
+const jumpToDefinitionKeymap = [
+    { key: 'F12', run: jumpToDefinition, preventDefault: true },
+];
+
+export { LanguageServerClient, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };