codemirror-languageserver 1.5.1 → 1.8.0

package/README.md

@@ -15,10 +15,20 @@ npm i codemirror-languageserver
 ``` js
 import { languageServer } from 'codemirror-languageserver';
 
+const transport = new WebSocketTransport(serverUri)
+
 var ls = languageServer({
-	serverUri: serverUri
-	rootUri: 'file:///'
-	documentUri: `file:///${filename}`
+	// WebSocket server uri and other client options.
+	serverUri,
+	rootUri: 'file:///',
+
+	// Alternatively, to share the same client across multiple instances of this plugin.
+	client: new LanguageServerClient({
+		serverUri,
+		rootUri: 'file:///'
+	}),
+
+	documentUri: `file:///${filename}`,
 	languageId: 'cpp' // As defined at https://microsoft.github.io/language-server-protocol/specification#textDocumentItem.
 });
 

package/dist/index.d.ts

@@ -1,8 +1,89 @@
-interface LanguageServerOptions {
-    serverUri: `ws://${string}` | `wss://${string}`;
-    rootUri: string;
+import { EditorView, Tooltip, ViewUpdate, PluginValue } from '@codemirror/view';
+import * as LSP from 'vscode-languageserver-protocol';
+import { CompletionTriggerKind, PublishDiagnosticsParams } from "vscode-languageserver-protocol";
+import { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+import { Transport } from '@open-rpc/client-js/build/transports/Transport';
+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];
+declare class LanguageServerClient {
+    private rootUri;
+    private workspaceFolders;
+    private autoClose?;
+    private transport;
+    private requestManager;
+    private client;
+    ready: boolean;
+    capabilities: LSP.ServerCapabilities<any>;
+    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;
+    client: LanguageServerClient;
+    private documentUri;
+    private languageId;
+    private documentVersion;
+    private changesTimeout;
+    constructor(view: EditorView);
+    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;
 }
-declare function languageServer(options: LanguageServerOptions): import("@codemirror/state").Extension[];
-export { languageServer };
+interface LanguageServerClientOptions extends LanguageServerBaseOptions {
+    transport: Transport;
+    autoClose?: boolean;
+}
+interface LanguageServerOptions extends LanguageServerClientOptions {
+    client?: LanguageServerClient;
+}
+interface LanguageServerWebsocketOptions extends LanguageServerBaseOptions {
+    serverUri: `ws://${string}` | `wss://${string}`;
+}
+declare function languageServer(options: LanguageServerWebsocketOptions): import("@codemirror/state").Extension[];
+declare function languageServerWithTransport(options: LanguageServerOptions): import("@codemirror/state").Extension[];
+export { LanguageServerClient, languageServer, languageServerWithTransport };

package/dist/index.js

@@ -1,58 +1,32 @@
 import { autocompletion } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
 import { Facet } from '@codemirror/state';
-import { hoverTooltip } from '@codemirror/tooltip';
-import { ViewPlugin, EditorView } from '@codemirror/view';
-import { WebSocketTransport, RequestManager, Client } from '@open-rpc/client-js';
+import { ViewPlugin, hoverTooltip, EditorView } from '@codemirror/view';
+import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
 import { CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity } from 'vscode-languageserver-protocol';
 
 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 serverUri = Facet.define({ combine: useLast });
-const rootUri = Facet.define({ combine: useLast });
+const client = Facet.define({ combine: useLast });
 const documentUri = Facet.define({ combine: useLast });
 const languageId = Facet.define({ combine: useLast });
-class LanguageServerPlugin {
-    constructor(view) {
-        this.view = view;
-        this.rootUri = this.view.state.facet(rootUri);
-        this.documentUri = this.view.state.facet(documentUri);
-        this.languageId = this.view.state.facet(languageId);
-        this.documentVersion = 0;
-        this.changesTimeout = 0;
-        this.transport = new WebSocketTransport(this.view.state.facet(serverUri));
+class LanguageServerClient {
+    constructor(options) {
+        this.rootUri = options.rootUri;
+        this.workspaceFolders = options.workspaceFolders;
+        this.autoClose = options.autoClose;
+        this.plugins = [];
+        this.transport = options.transport;
         this.requestManager = new RequestManager([this.transport]);
         this.client = new Client(this.requestManager);
         this.client.onNotification((data) => {
             this.processNotification(data);
         });
-        this.initialize({
-            documentText: this.view.state.doc.toString(),
-        });
-    }
-    update({ docChanged }) {
-        if (!docChanged)
-            return;
-        if (this.changesTimeout)
-            clearTimeout(this.changesTimeout);
-        this.changesTimeout = self.setTimeout(() => {
-            this.sendChange({
-                documentText: this.view.state.doc.toString(),
-            });
-        }, changesDelay);
-    }
-    destroy() {
-        this.client.close();
-    }
-    request(method, params, timeout) {
-        return this.client.request({ method, params }, timeout);
+        this.initialize();
     }
-    notify(method, params) {
-        return this.client.notify({ method, params });
-    }
-    async initialize({ documentText }) {
+    async initialize() {
         const { capabilities } = await this.request('initialize', {
             capabilities: {
                 textDocument: {
@@ -110,30 +84,91 @@ class LanguageServerPlugin {
             initializationOptions: null,
             processId: null,
             rootUri: this.rootUri,
-            workspaceFolders: [
-                {
-                    name: 'root',
-                    uri: this.rootUri,
-                },
-            ],
+            workspaceFolders: this.workspaceFolders,
         }, timeout * 3);
         this.capabilities = capabilities;
         this.notify('initialized', {});
-        this.notify('textDocument/didOpen', {
+        this.ready = true;
+    }
+    close() {
+        this.client.close();
+    }
+    textDocumentDidOpen(params) {
+        return this.notify('textDocument/didOpen', params);
+    }
+    textDocumentDidChange(params) {
+        return this.notify('textDocument/didChange', params);
+    }
+    async textDocumentHover(params) {
+        return await this.request('textDocument/hover', params, timeout);
+    }
+    async textDocumentCompletion(params) {
+        return await this.request('textDocument/completion', params, timeout);
+    }
+    attachPlugin(plugin) {
+        this.plugins.push(plugin);
+    }
+    detachPlugin(plugin) {
+        const i = this.plugins.indexOf(plugin);
+        if (i === -1)
+            return;
+        this.plugins.splice(i, 1);
+        if (this.autoClose)
+            this.close();
+    }
+    request(method, params, timeout) {
+        return this.client.request({ method, params }, timeout);
+    }
+    notify(method, params) {
+        return this.client.notify({ method, params });
+    }
+    processNotification(notification) {
+        for (const plugin of this.plugins)
+            plugin.processNotification(notification);
+    }
+}
+class LanguageServerPlugin {
+    constructor(view) {
+        this.view = view;
+        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);
+        this.initialize({
+            documentText: this.view.state.doc.toString(),
+        });
+    }
+    update({ docChanged }) {
+        if (!docChanged)
+            return;
+        if (this.changesTimeout)
+            clearTimeout(this.changesTimeout);
+        this.changesTimeout = self.setTimeout(() => {
+            this.sendChange({
+                documentText: this.view.state.doc.toString(),
+            });
+        }, changesDelay);
+    }
+    destroy() {
+        this.client.detachPlugin(this);
+    }
+    async initialize({ documentText }) {
+        this.client.textDocumentDidOpen({
             textDocument: {
                 uri: this.documentUri,
                 languageId: this.languageId,
                 text: documentText,
                 version: this.documentVersion,
-            },
+            }
         });
-        this.ready = true;
     }
     async sendChange({ documentText }) {
-        if (!this.ready)
+        if (!this.client.ready)
             return;
         try {
-            await this.notify('textDocument/didChange', {
+            await this.client.textDocumentDidChange({
                 textDocument: {
                     uri: this.documentUri,
                     version: this.documentVersion++,
@@ -149,13 +184,13 @@ class LanguageServerPlugin {
         this.sendChange({ documentText: view.state.doc.toString() });
     }
     async requestHoverTooltip(view, { line, character }) {
-        if (!this.ready || !this.capabilities.hoverProvider)
+        if (!this.client.ready || !this.client.capabilities.hoverProvider)
             return null;
         this.sendChange({ documentText: view.state.doc.toString() });
-        const result = await this.request('textDocument/hover', {
+        const result = await this.client.textDocumentHover({
             textDocument: { uri: this.documentUri },
             position: { line, character },
-        }, timeout);
+        });
         if (!result)
             return null;
         const { contents, range } = result;
@@ -173,19 +208,19 @@ class LanguageServerPlugin {
         return { pos, end, create: (view) => ({ dom }), above: true };
     }
     async requestCompletion(context, { line, character }, { triggerKind, triggerCharacter, }) {
-        if (!this.ready || !this.capabilities.completionProvider)
+        if (!this.client.ready || !this.client.capabilities.completionProvider)
             return null;
         this.sendChange({
             documentText: context.state.doc.toString(),
         });
-        const result = await this.request('textDocument/completion', {
+        const result = await this.client.textDocumentCompletion({
             textDocument: { uri: this.documentUri },
             position: { line, character },
             context: {
                 triggerKind,
                 triggerCharacter,
-            },
-        }, timeout);
+            }
+        });
         if (!result)
             return null;
         const items = 'items' in result ? result.items : result;
@@ -243,6 +278,8 @@ class LanguageServerPlugin {
         }
     }
     processDiagnostics(params) {
+        if (params.uri !== this.documentUri)
+            return;
         const diagnostics = params.diagnostics
             .map(({ range, message, severity }) => ({
             from: posToOffset(this.view.state.doc, range.start),
@@ -269,10 +306,17 @@ class LanguageServerPlugin {
     }
 }
 function languageServer(options) {
+    const serverUri = options.serverUri;
+    delete options.serverUri;
+    return languageServerWithTransport({
+        ...options,
+        transport: new WebSocketTransport(serverUri)
+    });
+}
+function languageServerWithTransport(options) {
     let plugin = null;
     return [
-        serverUri.of(options.serverUri),
-        rootUri.of(options.rootUri),
+        client.of(options.client || new LanguageServerClient({ ...options, autoClose: true })),
         documentUri.of(options.documentUri),
         languageId.of(options.languageId),
         ViewPlugin.define((view) => (plugin = new LanguageServerPlugin(view))),
@@ -291,7 +335,7 @@ function languageServer(options) {
                     let trigKind = CompletionTriggerKind.Invoked;
                     let trigChar;
                     if (!explicit &&
-                        ((_c = (_b = (_a = plugin.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]))) {
+                        ((_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];
                     }
@@ -371,4 +415,4 @@ const baseTheme = EditorView.baseTheme({
     },
 });
 
-export { languageServer };
+export { LanguageServerClient, languageServer, languageServerWithTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemirror-languageserver",
-  "version": "1.5.1",
+  "version": "1.8.0",
   "description": "Language Server Plugin for CodeMirror 6",
   "main": "dist/index.js",
   "scripts": {
@@ -30,11 +30,10 @@
     "typescript": "^4.2.4"
   },
   "dependencies": {
-    "@codemirror/autocomplete": "^0.19.8",
-    "@codemirror/lint": "^0.19.3",
-    "@codemirror/state": "^0.19.8",
-    "@codemirror/tooltip": "^0.19.14",
-    "@codemirror/view": "^0.19.43",
+    "@codemirror/autocomplete": "^0.20.0",
+    "@codemirror/lint": "^0.20.0",
+    "@codemirror/state": "^0.20.0",
+    "@codemirror/view": "^0.20.0",
     "@open-rpc/client-js": "^1.7.1",
     "vscode-languageserver-protocol": "^3.16.0"
   },

package/dist/index.d.sync-conflict-20210813-102235-QZ53W3J.ts

@@ -1,10 +0,0 @@
-interface LanguageServerOptions {
-    serverUri: `ws://${string}` | `wss://${string}`;
-    rootUri: string;
-    documentUri: string;
-    languageId: string;
-    onConnect(): void;
-    onDisconnect(): void;
-}
-declare function languageServer(options: LanguageServerOptions): import("@codemirror/state").Extension[];
-export { languageServer };