codemirror-languageserver 1.14.0 → 1.16.0

package/dist/index.d.ts

@@ -1,98 +1,15 @@
-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;
+export { LanguageServerClient, languageServerPlugin } from './plugin';
+export { jumpToDefinition, jumpToDefinitionPos, jumpToDefinitionKeymap, } from './definition';
+export { PyrightInitializationOptions, RustAnalyzerInitializationOptions, TypeScriptInitializationOptions, ESLintInitializationOptions, ClangdInitializationOptions, GoplsInitializationOptions, } from './initialization';
+import { LanguageServerClient } from './plugin';
+import type { LanguageServerClientOptions, LanguageServerBaseOptions } from './plugin';
+interface LanguageServerOptions<InitializationOptions = unknown> extends LanguageServerClientOptions<InitializationOptions> {
+    client?: LanguageServerClient<InitializationOptions>;
     allowHTMLContent?: boolean;
 }
-interface LanguageServerWebsocketOptions extends LanguageServerBaseOptions {
+interface LanguageServerWebsocketOptions<InitializationOptions = unknown> extends LanguageServerBaseOptions {
     serverUri: `ws://${string}` | `wss://${string}`;
+    initializationOptions?: InitializationOptions;
 }
-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 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[];

package/dist/index.js

@@ -1,22 +1,41 @@
-import { autocompletion, insertCompletionText } from '@codemirror/autocomplete';
+import { insertCompletionText, autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
 import { Facet } from '@codemirror/state';
-import { ViewPlugin, hoverTooltip } from '@codemirror/view';
+import { ViewPlugin, hoverTooltip as hoverTooltip$1, EditorView, keymap } from '@codemirror/view';
 import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
-import { CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity } from 'vscode-languageserver-protocol';
+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({
+Facet.define({
     combine: useLast,
 });
-const documentUri = Facet.define({ combine: useLast });
-const languageId = Facet.define({ combine: useLast });
+Facet.define({ combine: useLast });
+Facet.define({ combine: useLast });
 class LanguageServerClient {
     constructor(options) {
+        this.options = options;
         this.rootUri = options.rootUri;
         this.workspaceFolders = options.workspaceFolders;
         this.autoClose = options.autoClose;
@@ -44,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: ['markdown', 'plaintext'],
                     },
                     moniker: {},
                     synchronization: {
@@ -64,16 +84,16 @@ class LanguageServerClient {
                         completionItem: {
                             snippetSupport: false,
                             commitCharactersSupport: true,
-                            documentationFormat: ['plaintext', 'markdown'],
+                            documentationFormat: ['markdown', 'plaintext'],
                             deprecatedSupport: false,
                             preselectSupport: false,
                         },
-                        contextSupport: false,
+                        contextSupport: true,
                     },
                     signatureHelp: {
                         dynamicRegistration: true,
                         signatureInformation: {
-                            documentationFormat: ['plaintext', 'markdown'],
+                            documentationFormat: ['markdown', 'plaintext'],
                         },
                     },
                     declaration: {
@@ -99,11 +119,14 @@ 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.ready = true;
@@ -123,6 +146,15 @@ class LanguageServerClient {
     async textDocumentCompletion(params) {
         return await this.request('textDocument/completion', params, timeout);
     }
+    async textDocumentDefinition(params) {
+        return await this.request('textDocument/definition', params, timeout);
+    }
+    async textDocumentDeclaration(params) {
+        return await this.request('textDocument/declaration', params, timeout);
+    }
+    async textDocumentTypeDefinition(params) {
+        return await this.request('textDocument/typeDefinition', params, timeout);
+    }
     attachPlugin(plugin) {
         this.plugins.push(plugin);
     }
@@ -149,12 +181,12 @@ class LanguageServerClient {
     }
 }
 class LanguageServerPlugin {
-    constructor(view, allowHTMLContent) {
+    constructor(view, { client, documentUri, languageId, allowHTMLContent, }) {
         this.view = view;
+        this.client = client;
+        this.documentUri = documentUri;
+        this.languageId = languageId;
         this.allowHTMLContent = allowHTMLContent;
-        this.client = this.view.state.facet(client);
-        this.documentUri = this.view.state.facet(documentUri);
-        this.languageId = this.view.state.facet(languageId);
         this.documentVersion = 0;
         this.changesTimeout = 0;
         this.client.attachPlugin(this);
@@ -356,6 +388,44 @@ class LanguageServerPlugin {
             filter: false,
         };
     }
+    async requestLocation(view, { line, character }, capability, method) {
+        if (!this.client.ready || !this.client.capabilities[capability]) {
+            return null;
+        }
+        const result = await this.client[method]({
+            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),
+                },
+                scrollIntoView: true,
+            }));
+        }
+        return {
+            uri,
+            range,
+        };
+    }
+    async requestDefinition(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'definitionProvider', 'textDocumentDefinition');
+    }
+    async requestDeclaration(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'declarationProvider', 'textDocumentDeclaration');
+    }
+    async requestTypeDefinition(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'typeDefinitionProvider', 'textDocumentTypeDefinition');
+    }
     processNotification(notification) {
         try {
             switch (notification.method) {
@@ -399,72 +469,7 @@ class LanguageServerPlugin {
         this.view.dispatch(setDiagnostics(this.view.state, diagnostics));
     }
 }
-function languageServer(options) {
-    const serverUri = options.serverUri;
-    delete options.serverUri;
-    return languageServerWithTransport({
-        ...options,
-        transport: new WebSocketTransport(serverUri),
-    });
-}
-function languageServerWithTransport(options) {
-    let plugin = null;
-    return [
-        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))),
-        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;
-        }),
-        autocompletion({
-            override: [
-                async (context) => {
-                    var _a, _b, _c;
-                    if (plugin == null) {
-                        return null;
-                    }
-                    const { state, pos, explicit } = context;
-                    const line = state.doc.lineAt(pos);
-                    let trigKind = CompletionTriggerKind.Invoked;
-                    let trigChar;
-                    if (!explicit &&
-                        ((_c = (_b = (_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.completionProvider) === null || _b === void 0 ? void 0 : _b.triggerCharacters) === null || _c === void 0 ? void 0 : _c.includes(line.text[pos - line.from - 1]))) {
-                        trigKind = CompletionTriggerKind.TriggerCharacter;
-                        trigChar = line.text[pos - line.from - 1];
-                    }
-                    if (trigKind === CompletionTriggerKind.Invoked &&
-                        !context.matchBefore(/\w+$/)) {
-                        return null;
-                    }
-                    return await plugin.requestCompletion(context, offsetToPos(state.doc, pos), {
-                        triggerCharacter: trigChar,
-                        triggerKind: trigKind,
-                    });
-                },
-            ],
-        }),
-    ];
-}
-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 languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
         let value = contents.value;
@@ -495,10 +500,11 @@ function prefixMatch(items) {
     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) + '*$';
@@ -511,4 +517,104 @@ function isLSPMarkupContent(contents) {
     return contents.kind !== undefined;
 }
 
-export { LanguageServerClient, languageServer, languageServerWithTransport };
+function requestDefinition(view, pos) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    plugin.requestDefinition(view, offsetToPos(view.state.doc, pos));
+    return true;
+}
+function requestTypeDefinition(view, pos) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    plugin.requestTypeDefinition(view, offsetToPos(view.state.doc, pos));
+    return true;
+}
+const jumpToDefinition = (view) => requestDefinition(view, view.state.selection.main.head);
+const jumpToDefinitionPos = (pos) => (view) => requestDefinition(view, pos);
+const jumpToTypeDefinition = (view) => requestTypeDefinition(view, view.state.selection.main.head);
+const jumpToTypeDefinitionPos = (pos) => (view) => requestTypeDefinition(view, pos);
+const jumpToDefinitionKeymap = [
+    { key: 'F12', run: jumpToDefinition, preventDefault: true },
+    { key: 'Mod-F12', run: jumpToTypeDefinition, preventDefault: true },
+];
+
+const hoverTooltip = () => hoverTooltip$1((view, pos) => {
+    var _a;
+    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);
+});
+
+const autocompletion = () => autocompletion$1({
+    override: [
+        async (context) => {
+            var _a, _b, _c;
+            const { state, pos, explicit, view } = context;
+            const plugin = view.plugin(languageServerPlugin);
+            if (plugin == null)
+                return null;
+            const line = state.doc.lineAt(pos);
+            let trigKind = CompletionTriggerKind.Invoked;
+            let trigChar;
+            if (!explicit &&
+                ((_c = (_b = (_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.completionProvider) === null || _b === void 0 ? void 0 : _b.triggerCharacters) === null || _c === void 0 ? void 0 : _c.includes(line.text[pos - line.from - 1]))) {
+                trigKind = CompletionTriggerKind.TriggerCharacter;
+                trigChar = line.text[pos - line.from - 1];
+            }
+            if (trigKind === CompletionTriggerKind.Invoked &&
+                !context.matchBefore(/\w+$/)) {
+                return null;
+            }
+            return await plugin.requestCompletion(context, offsetToPos(state.doc, pos), {
+                triggerCharacter: trigChar,
+                triggerKind: trigKind,
+            });
+        },
+    ],
+});
+
+const mouseHandler = () => EditorView.domEventHandlers({
+    mousedown: (event, view) => {
+        if (!event.ctrlKey && !event.metaKey)
+            return;
+        const pos = view.posAtCoords({
+            x: event.clientX,
+            y: event.clientY,
+        });
+        const ok = (event.shiftKey
+            ? jumpToTypeDefinitionPos(pos)
+            : jumpToDefinitionPos(pos))(view);
+        if (ok)
+            event.preventDefault();
+    },
+});
+
+function languageServer(options) {
+    const serverUri = options.serverUri;
+    const { serverUri: _, ...optionsWithoutServerUri } = options;
+    return languageServerWithTransport({
+        ...optionsWithoutServerUri,
+        transport: new WebSocketTransport(serverUri),
+    });
+}
+function languageServerWithTransport(options) {
+    return [
+        languageServerPlugin.of({
+            client: options.client ||
+                new LanguageServerClient({
+                    ...options,
+                    autoClose: true,
+                }),
+            documentUri: options.documentUri,
+            languageId: options.languageId,
+            allowHTMLContent: options.allowHTMLContent,
+        }),
+        hoverTooltip(),
+        autocompletion(),
+        keymap.of([...jumpToDefinitionKeymap]),
+        mouseHandler(),
+    ];
+}
+
+export { LanguageServerClient, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };