@jupyterlab/lsp 4.6.0 → 4.7.0-alpha.0

package/src/adapters/adapter.ts

@@ -525,21 +525,40 @@ export abstract class WidgetLSPAdapter<
     virtualDocument: VirtualDocument,
     sendOpen = false
   ): Promise<void> {
-    virtualDocument.foreignDocumentOpened.connect(
-      this.onForeignDocumentOpened,
-      this
-    );
-    const connectionContext = await this._connect(virtualDocument).catch(
-      console.error
-    );
+    if (this._isDisposed || virtualDocument.isDisposed) {
+      return;
+    }
 
-    if (connectionContext && connectionContext.connection) {
-      virtualDocument.changed.connect(this.documentChanged, this);
-      if (sendOpen) {
-        connectionContext.connection.sendOpenWhenReady(
-          virtualDocument.documentInfo
-        );
+    const pendingConnection =
+      this._pendingDocumentConnections.get(virtualDocument);
+    if (pendingConnection) {
+      return pendingConnection;
+    }
+
+    const connectionPromise = (async () => {
+      virtualDocument.foreignDocumentOpened.connect(
+        this.onForeignDocumentOpened,
+        this
+      );
+      const connectionContext = await this._connect(virtualDocument).catch(
+        console.error
+      );
+
+      if (connectionContext && connectionContext.connection) {
+        virtualDocument.changed.connect(this.documentChanged, this);
+        if (sendOpen) {
+          connectionContext.connection.sendOpenWhenReady(
+            virtualDocument.documentInfo
+          );
+        }
       }
+    })();
+    this._pendingDocumentConnections.set(virtualDocument, connectionPromise);
+
+    try {
+      await connectionPromise;
+    } finally {
+      this._pendingDocumentConnections.delete(virtualDocument);
     }
   }
 
@@ -549,7 +568,7 @@ export abstract class WidgetLSPAdapter<
   protected initVirtual(): void {
     this._virtualDocument?.dispose();
     this._virtualDocument = this.createVirtualDocument();
-    this._onLspSessionOrFeatureChanged();
+    this._toggleVirtualDocumentUpdates();
   }
 
   /**
@@ -616,6 +635,11 @@ export abstract class WidgetLSPAdapter<
   private _updateFinished: Promise<void>;
   private _virtualDocument: VirtualDocument | null = null;
   private _editorToAdapter: WeakMap<Document.IEditor, EditorAdapter>;
+  private _pendingDocumentConnections = new WeakMap<
+    VirtualDocument,
+    Promise<void>
+  >();
+  private _queuedConnectionRetries = new WeakSet<VirtualDocument>();
 
   private _onEditorAdded(
     sender: WidgetLSPAdapter<T>,
@@ -697,6 +721,10 @@ export abstract class WidgetLSPAdapter<
 
     let connection = await this.connectionManager.connect(options);
 
+    if (this._isDisposed || virtualDocument.isDisposed) {
+      return undefined;
+    }
+
     if (connection) {
       await this.onConnected({ virtualDocument, connection });
 
@@ -755,6 +783,10 @@ export abstract class WidgetLSPAdapter<
    * the LSP server status changed or when a LSP feature is registered.
    */
   private _onLspSessionOrFeatureChanged(): void {
+    this._toggleVirtualDocumentUpdates(true);
+  }
+
+  private _toggleVirtualDocumentUpdates(retryConnection = false): void {
     if (!this._virtualDocument) {
       return;
     }
@@ -763,8 +795,49 @@ export abstract class WidgetLSPAdapter<
 
     if (this._shouldUpdateVirtualDocument()) {
       model.contentChanged.connect(this._onContentChanged, this);
+      if (retryConnection) {
+        this._connectVirtualDocumentIfNeeded(this._virtualDocument);
+      }
     } else {
       model.contentChanged.disconnect(this._onContentChanged, this);
     }
   }
+
+  private _connectVirtualDocumentIfNeeded(
+    virtualDocument: VirtualDocument
+  ): void {
+    if (
+      this._isDisposed ||
+      virtualDocument.isDisposed ||
+      this.connectionManager.connections.has(virtualDocument.uri)
+    ) {
+      return;
+    }
+
+    const pendingConnection =
+      this._pendingDocumentConnections.get(virtualDocument);
+    if (pendingConnection) {
+      if (this._queuedConnectionRetries.has(virtualDocument)) {
+        return;
+      }
+      this._queuedConnectionRetries.add(virtualDocument);
+      void pendingConnection
+        .finally(() => {
+          if (!this._queuedConnectionRetries.delete(virtualDocument)) {
+            return;
+          }
+          if (
+            this._virtualDocument === virtualDocument &&
+            this._shouldUpdateVirtualDocument() &&
+            !this.connectionManager.connections.has(virtualDocument.uri)
+          ) {
+            this._connectVirtualDocumentIfNeeded(virtualDocument);
+          }
+        })
+        .catch(console.warn);
+      return;
+    }
+
+    this.connectDocument(virtualDocument, false).catch(console.warn);
+  }
 }

package/src/adapters/editorAdapter.ts

@@ -1,6 +1,5 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import type {
   IConfigurableExtension,
@@ -74,7 +73,7 @@ export class EditorAdapter implements IDisposable {
     });
   }
 
-  private _widgetAdapter: WidgetLSPAdapter<any>;
+  private _widgetAdapter: WidgetLSPAdapter;
   private _extensions: EditorAdapter.ILSPEditorExtensionFactory[];
 }
 
@@ -103,7 +102,7 @@ export namespace EditorAdapter {
   }
 
   export interface ILSPEditorExtensionFactory extends Omit<
-    IEditorExtensionFactory<any>,
+    IEditorExtensionFactory<unknown>,
     'factory'
   > {
     /**
@@ -114,7 +113,7 @@ export namespace EditorAdapter {
      */
     readonly factory: (
       options: IFactoryOptions
-    ) => IConfigurableExtension<any> | null;
+    ) => IConfigurableExtension<unknown> | null;
   }
 
   export interface IFactoryOptions extends IEditorExtensionFactory.IOptions {
@@ -129,6 +128,6 @@ export namespace EditorAdapter {
     /**
      * The widget lsp adapter.
      */
-    widgetAdapter: WidgetLSPAdapter<any>;
+    widgetAdapter: WidgetLSPAdapter;
   }
 }

package/src/connection.ts

@@ -183,6 +183,42 @@ interface IMessageLog<T extends AnyMethod = AnyMethod> {
   message: any;
 }
 
+interface ICancellationDisposable {
+  dispose(): void;
+}
+
+interface ISignalCancellationToken {
+  readonly isCancellationRequested: boolean;
+  onCancellationRequested(
+    listener: (event: unknown) => void,
+    thisArgs?: unknown,
+    disposables?: ICancellationDisposable[]
+  ): ICancellationDisposable;
+}
+
+function cancellationTokenFromSignal(
+  signal: AbortSignal
+): ISignalCancellationToken {
+  return {
+    get isCancellationRequested(): boolean {
+      return signal.aborted;
+    },
+    onCancellationRequested: (listener, thisArgs, disposables) => {
+      const onAbort = () => {
+        listener.call(thisArgs, undefined);
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+      const disposable = {
+        dispose: () => {
+          signal.removeEventListener('abort', onAbort);
+        }
+      };
+      disposables?.push(disposable);
+      return disposable;
+    }
+  };
+}
+
 export class LSPConnection extends LspWsConnection implements ILSPConnection {
   constructor(options: ILSPOptions) {
     super(options);
@@ -324,6 +360,67 @@ export class LSPConnection extends LspWsConnection implements ILSPConnection {
     return !!(this.serverCapabilities && this.serverCapabilities[capability]);
   }
 
+  /**
+   * Send a request to the language server.
+   */
+  async request<M extends Method.ClientRequest>(
+    method: M,
+    params: IClientRequestParams[M],
+    options: ILSPConnection.IRequestOptions = {}
+  ): Promise<IClientResult[M]> {
+    if (this.isDisposed) {
+      throw new Error('Cannot send an LSP request on a disposed connection.');
+    }
+    if (!this.isReady) {
+      throw new Error(
+        'Cannot send an LSP request before the connection is ready.'
+      );
+    }
+
+    const { signal } = options;
+    if (signal?.aborted) {
+      throw (
+        signal.reason ??
+        new DOMException('The request was aborted.', 'AbortError')
+      );
+    }
+
+    const cancellation = signal
+      ? cancellationTokenFromSignal(signal)
+      : undefined;
+    let rejectOnAbort: ((reason?: unknown) => void) | undefined;
+    const aborted = signal
+      ? new Promise<never>((_, reject) => {
+          rejectOnAbort = reject;
+        })
+      : undefined;
+    const cancel = () => {
+      rejectOnAbort?.(
+        signal?.reason ??
+          new DOMException('The request was aborted.', 'AbortError')
+      );
+    };
+    signal?.addEventListener('abort', cancel, { once: true });
+
+    this.log(MessageKind.clientRequested, { method, message: params });
+    try {
+      const response = cancellation
+        ? this.connection.sendRequest<IClientResult[M]>(
+            method,
+            params,
+            cancellation
+          )
+        : this.connection.sendRequest<IClientResult[M]>(method, params);
+      const result = aborted
+        ? await Promise.race([response, aborted])
+        : await response;
+      this.log(MessageKind.resultForClient, { method, message: result });
+      return result;
+    } finally {
+      signal?.removeEventListener('abort', cancel);
+    }
+  }
+
   /**
    * Close the connection to the server.
    */

package/src/connection_manager.ts

@@ -370,7 +370,8 @@ export class DocumentConnectionManager implements ILSPDocumentConnectionManager
 
   /**
    * Create a new connection to the language server
-   * @return A promise of the LSP connection
+   *
+   * Returns a promise of the LSP connection.
    */
   async connect(
     options: ISocketConnectionOptions,
@@ -487,7 +488,7 @@ export class DocumentConnectionManager implements ILSPDocumentConnectionManager
   /**
    * Create the LSP connection for requested virtual document.
    *
-   * @return  Return the promise of the LSP connection.
+   * Returns a promise of the LSP connection.
    */
 
   private async _connectSocket(
@@ -725,8 +726,17 @@ namespace Private {
   ): Promise<LSPConnection> {
     let connection = _connections.get(languageServerId);
     if (!connection) {
-      const { settings } = Private.getLanguageServerManager();
-      const socket = new settings.WebSocket(uris.socket);
+      const serverManager = Private.getLanguageServerManager();
+      const { settings } = serverManager;
+      const transportFactory =
+        serverManager.getTransportFactory(languageServerId);
+      const socket = transportFactory
+        ? transportFactory({
+            languageServerId,
+            socketUrl: uris.socket,
+            settings
+          })
+        : new settings.WebSocket(uris.socket);
       const connection = new LSPConnection({
         languageId: language,
         serverUri: uris.server,

package/src/manager.ts

@@ -1,13 +1,16 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { DisposableDelegate } from '@lumino/disposable';
+import type { IDisposable } from '@lumino/disposable';
 import type { ISignal } from '@lumino/signaling';
 import { Signal } from '@lumino/signaling';
 
 import type {
+  ILanguageServerProvider,
   TLanguageServerConfigurations,
   TLanguageServerId,
   TSessionMap,
@@ -15,7 +18,11 @@ import type {
 } from './tokens';
 import { ILanguageServerManager } from './tokens';
 import type { ServerSpecProperties } from './schema';
-import { PromiseDelegate } from '@lumino/coreutils';
+
+interface IProviderRegistration {
+  provider: ILanguageServerProvider;
+  onSessionsChanged: () => void;
+}
 
 export class LanguageServerManager implements ILanguageServerManager {
   constructor(options: ILanguageServerManager.IOptions) {
@@ -106,6 +113,10 @@ export class LanguageServerManager implements ILanguageServerManager {
   disable(): void {
     this._enabled = false;
     this._sessions = new Map();
+    this._specs = new Map();
+    this._serverSessions = new Map();
+    this._serverSpecs = new Map();
+    this._transports.clear();
     this._sessionsChanged.emit(void 0);
   }
 
@@ -118,6 +129,18 @@ export class LanguageServerManager implements ILanguageServerManager {
     }
     this._isDisposed = true;
 
+    for (const registration of this._providers.values()) {
+      if (registration.provider.sessionsChanged) {
+        registration.provider.sessionsChanged.disconnect(
+          registration.onSessionsChanged
+        );
+      }
+    }
+    this._providers.clear();
+    this._serverSessions.clear();
+    this._serverSpecs.clear();
+    this._transports.clear();
+
     Signal.clearData(this);
   }
 
@@ -128,6 +151,52 @@ export class LanguageServerManager implements ILanguageServerManager {
     this._configuration = configuration;
   }
 
+  /**
+   * Register a runtime language server provider.
+   */
+  registerProvider(provider: ILanguageServerProvider): IDisposable {
+    if (this._providers.has(provider.id)) {
+      console.warn(
+        `Language server provider with id ${provider.id} is already registered`
+      );
+      return new DisposableDelegate(() => undefined);
+    }
+
+    const registration = {
+      provider,
+      onSessionsChanged: () => {
+        void this.fetchSessions().catch(console.error);
+      }
+    };
+    this._providers.set(provider.id, registration);
+
+    if (provider.sessionsChanged) {
+      provider.sessionsChanged.connect(registration.onSessionsChanged);
+    }
+
+    void this.fetchSessions().catch(console.error);
+
+    return new DisposableDelegate(() => {
+      if (this._providers.get(provider.id) !== registration) {
+        return;
+      }
+      if (provider.sessionsChanged) {
+        provider.sessionsChanged.disconnect(registration.onSessionsChanged);
+      }
+      this._providers.delete(provider.id);
+      void this.fetchSessions().catch(console.error);
+    });
+  }
+
+  /**
+   * Get a runtime transport factory for a language server.
+   */
+  getTransportFactory(
+    languageServerId: TLanguageServerId
+  ): ILanguageServerProvider.TTransportFactory | null {
+    return this._transports.get(languageServerId) ?? null;
+  }
+
   /**
    * Get matching language server for input language option.
    */
@@ -176,58 +245,62 @@ export class LanguageServerManager implements ILanguageServerManager {
     if (!this._enabled) {
       return;
     }
-    let response = await ServerConnection.makeRequest(
-      this.statusUrl,
-      { method: 'GET' },
-      this._settings
-    );
-
-    this._statusCode = response.status;
-    if (!response.ok) {
-      if (this._retries > 0) {
-        this._retries -= 1;
-        setTimeout(this.fetchSessions.bind(this), this._retriesInterval);
-      } else {
-        this._ready.resolve(undefined);
-        console.log('Missing jupyter_lsp server extension, skipping.');
-      }
+    let statusCode = this._statusCode;
+    const sessions: TSessionMap = new Map();
+    const specs: TSpecsMap = new Map();
+    const transports = new Map<
+      TLanguageServerId,
+      ILanguageServerProvider.TTransportFactory
+    >();
+
+    const serverData = await this._fetchServerData();
+    if (serverData?.statusCode !== undefined) {
+      statusCode = serverData.statusCode;
+      this._statusCode = statusCode;
+    }
+    if (serverData?.retryScheduled && this._providers.size === 0) {
       return;
     }
+    if (serverData?.sessions !== undefined) {
+      this._syncSnapshot(this._serverSessions, serverData.sessions);
+    }
+    if (serverData?.specs !== undefined) {
+      this._syncSnapshot(this._serverSpecs, serverData.specs);
+    }
+    if (serverData) {
+      if (serverData.version !== undefined) {
+        this.version = serverData.version;
+      }
+    }
 
-    let sessions: { [key: string]: any };
+    this._mergeSnapshot(specs, this._serverSpecs);
+    this._mergeSnapshot(sessions, this._serverSessions);
 
-    try {
-      const data = await response.json();
-      sessions = data.sessions;
+    for (const registration of this._providers.values()) {
       try {
-        this.version = data.version;
-        this._specs = new Map(Object.entries(data.specs)) as TSpecsMap;
+        const data = await registration.provider.fetch();
+        if (!data) {
+          continue;
+        }
+        if (data.statusCode !== undefined) {
+          statusCode = data.statusCode;
+        }
+        this._mergeSnapshot(specs, data.specs);
+        this._mergeSnapshot(sessions, data.sessions);
+        if (data.transport) {
+          for (const [key, factory] of Object.entries(data.transport)) {
+            transports.set(key as TLanguageServerId, factory);
+          }
+        }
       } catch (err) {
         console.warn(err);
       }
-    } catch (err) {
-      console.warn(err);
-      this._ready.resolve(undefined);
-      return;
     }
 
-    for (let key of Object.keys(sessions)) {
-      let id: TLanguageServerId = key as TLanguageServerId;
-      if (this._sessions.has(id)) {
-        Object.assign(this._sessions.get(id) || {}, sessions[key]);
-      } else {
-        this._sessions.set(id, sessions[key]);
-      }
-    }
-
-    const oldKeys = this._sessions.keys();
-
-    for (const oldKey in oldKeys) {
-      if (!sessions[oldKey]) {
-        let oldId = oldKey as TLanguageServerId;
-        this._sessions.delete(oldId);
-      }
-    }
+    this._statusCode = statusCode;
+    this._transports = transports;
+    this._syncSnapshot(this._specs, specs);
+    this._syncSnapshot(this._sessions, sessions);
     this._sessionsChanged.emit(void 0);
     this._ready.resolve(undefined);
   }
@@ -280,6 +353,95 @@ export class LanguageServerManager implements ILanguageServerManager {
     return bRank - aRank;
   }
 
+  /**
+   * Fetch language server data from the HTTP endpoint.
+   */
+  private async _fetchServerData(): Promise<
+    | (ILanguageServerProvider.IFetchResult & {
+        version?: number;
+        retryScheduled?: boolean;
+      })
+    | null
+  > {
+    let response: Response;
+
+    try {
+      response = await ServerConnection.makeRequest(
+        this.statusUrl,
+        { method: 'GET' },
+        this._settings
+      );
+    } catch (err) {
+      console.warn(err);
+      return null;
+    }
+
+    if (!response.ok) {
+      if (this._retries > 0) {
+        this._retries -= 1;
+        setTimeout(this.fetchSessions.bind(this), this._retriesInterval);
+        return { statusCode: response.status, retryScheduled: true };
+      } else {
+        console.log('Missing jupyter_lsp server extension, skipping.');
+      }
+      return { statusCode: response.status };
+    }
+
+    try {
+      const data = await response.json();
+      return {
+        statusCode: response.status,
+        version: data.version,
+        sessions: data.sessions,
+        specs: data.specs
+      };
+    } catch (err) {
+      console.warn(err);
+      return { statusCode: response.status };
+    }
+  }
+
+  /**
+   * Merge provider snapshot into target map.
+   */
+  private _mergeSnapshot<T>(
+    target: Map<TLanguageServerId, T>,
+    source?: Map<TLanguageServerId, T> | { [key: string]: T }
+  ): void {
+    if (!source) {
+      return;
+    }
+    const entries =
+      source instanceof Map ? source.entries() : Object.entries(source);
+
+    for (const [key, value] of entries) {
+      target.set(key as TLanguageServerId, value);
+    }
+  }
+
+  /**
+   * Synchronize a mutable map in place.
+   */
+  private _syncSnapshot<T>(
+    target: Map<TLanguageServerId, T>,
+    source: Map<TLanguageServerId, T> | { [key: string]: T }
+  ): void {
+    const entries =
+      source instanceof Map ? source.entries() : Object.entries(source);
+    const nextKeys = new Set<TLanguageServerId>();
+
+    for (const [key, value] of entries) {
+      const id = key as TLanguageServerId;
+      nextKeys.add(id);
+      target.set(id, value);
+    }
+    for (const key of Array.from(target.keys())) {
+      if (!nextKeys.has(key)) {
+        target.delete(key);
+      }
+    }
+  }
+
   /**
    * Get the base URL for language server requests.
    */
@@ -297,6 +459,16 @@ export class LanguageServerManager implements ILanguageServerManager {
    */
   private _specs: TSpecsMap = new Map();
 
+  /**
+   * Last known language server sessions from HTTP status endpoint.
+   */
+  private _serverSessions: TSessionMap = new Map();
+
+  /**
+   * Last known language server specs from HTTP status endpoint.
+   */
+  private _serverSpecs: TSpecsMap = new Map();
+
   /**
    * Server connection setting.
    */
@@ -344,6 +516,19 @@ export class LanguageServerManager implements ILanguageServerManager {
     this
   );
 
+  /**
+   * Runtime language server providers.
+   */
+  private _providers = new Map<string, IProviderRegistration>();
+
+  /**
+   * Runtime language server transport factories.
+   */
+  private _transports = new Map<
+    TLanguageServerId,
+    ILanguageServerProvider.TTransportFactory
+  >();
+
   private _isDisposed = false;
 
   /**

package/src/plugin.ts

@@ -11,7 +11,7 @@
 /**
  * Enable or disable the language server services.
  */
-export type Activate = Off | On;
+export type Activate = (Off | On) & string;
 export type Off = 'off';
 export type On = 'on';
 /**
@@ -21,7 +21,8 @@ export type RankOfTheServer = number;
 /**
  * Whether to ask server to send logs with execution trace (for debugging). Accepted values are: "off", "messages", "verbose". Servers are allowed to ignore this request.
  */
-export type AskServersToSendTraceNotifications = Off1 | Messages | Verbose;
+export type AskServersToSendTraceNotifications = (Off1 | Messages | Verbose) &
+  string;
 export type Off1 = 'off';
 export type Messages = 'messages';
 export type Verbose = 'verbose';