@jupyterlab/lsp 4.0.6 → 4.1.0-alpha.2

package/src/adapters/adapter.ts

@@ -25,6 +25,7 @@ import {
   ISocketConnectionOptions
 } from '../tokens';
 import { VirtualDocument } from '../virtual/document';
+import { EditorAdapter } from './editorAdapter';
 
 type IButton = Dialog.IButton;
 const createButton = Dialog.createButton;
@@ -74,8 +75,9 @@ export interface IAdapterOptions {
  * as this would make the logic of inspections caching impossible to maintain, thus the WidgetAdapter
  * has to handle that, keeping multiple connections and multiple virtual documents.
  */
-export abstract class WidgetLSPAdapter<T extends IDocumentWidget>
-  implements IDisposable
+export abstract class WidgetLSPAdapter<
+  T extends IDocumentWidget = IDocumentWidget
+> implements IDisposable
 {
   // note: it could be using namespace/IOptions pattern,
   // but I do not know how to make it work with the generic type T
@@ -91,6 +93,10 @@ export abstract class WidgetLSPAdapter<T extends IDocumentWidget>
     this.widget.context.saveState.connect(this.onSaveState, this);
     this.connectionManager.closed.connect(this.onConnectionClosed, this);
     this.widget.disposed.connect(this.dispose, this);
+
+    this._editorToAdapter = new WeakMap();
+    this.editorAdded.connect(this._onEditorAdded, this);
+    this.editorRemoved.connect(this._onEditorRemoved, this);
   }
 
   /**
@@ -263,6 +269,8 @@ export abstract class WidgetLSPAdapter<T extends IDocumentWidget>
     if (this._isDisposed) {
       return;
     }
+    this.editorAdded.disconnect(this._onEditorAdded, this);
+    this.editorRemoved.disconnect(this._onEditorRemoved, this);
     this._isDisposed = true;
     this.disconnect();
     this._virtualDocument = null;
@@ -592,6 +600,30 @@ export abstract class WidgetLSPAdapter<T extends IDocumentWidget>
   private _isConnected: boolean;
   private _updateFinished: Promise<void>;
   private _virtualDocument: VirtualDocument | null = null;
+  private _editorToAdapter: WeakMap<Document.IEditor, EditorAdapter>;
+
+  private _onEditorAdded(
+    sender: WidgetLSPAdapter<T>,
+    change: IEditorChangedData
+  ): void {
+    const { editor } = change;
+    const editorAdapter = new EditorAdapter({
+      editor: editor,
+      widgetAdapter: this,
+      extensions: this.options.featureManager.extensionFactories()
+    });
+    this._editorToAdapter.set(editor, editorAdapter);
+  }
+
+  private _onEditorRemoved(
+    sender: WidgetLSPAdapter<T>,
+    change: IEditorChangedData
+  ): void {
+    const { editor } = change;
+    const adapter = this._editorToAdapter.get(editor);
+    adapter?.dispose();
+    this._editorToAdapter.delete(editor);
+  }
 
   /**
    * Callback called when a foreign document is closed,

package/src/adapters/editorAdapter.ts

@@ -0,0 +1,131 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import {
+  IConfigurableExtension,
+  IEditorExtensionFactory
+} from '@jupyterlab/codemirror';
+
+import { IDisposable } from '@lumino/disposable';
+
+import { Signal } from '@lumino/signaling';
+
+import { WidgetLSPAdapter } from './adapter';
+import { Document } from '../tokens';
+
+/**
+ * The CodeEditor.IEditor adapter.
+ */
+export class EditorAdapter implements IDisposable {
+  /**
+   * Instantiate a new EditorAdapter.
+   *
+   * @param options The instantiation options for a EditorAdapter.
+   */
+  constructor(options: EditorAdapter.IOptions) {
+    this._widgetAdapter = options.widgetAdapter;
+    this._extensions = options.extensions;
+
+    void options.editor.ready().then(editor => {
+      this._injectExtensions(options.editor);
+    });
+  }
+
+  /**
+   * Whether the handler is disposed.
+   */
+  isDisposed: boolean;
+
+  /**
+   * Dispose the handler.
+   */
+  dispose(): void {
+    if (this.isDisposed) {
+      return;
+    }
+    this.isDisposed = true;
+    Signal.clearData(this);
+  }
+
+  /**
+   * Setup the editor.
+   */
+  private _injectExtensions(editor: Document.IEditor): void {
+    const codeEditor = editor.getEditor()!;
+    if (codeEditor.isDisposed) {
+      return;
+    }
+
+    this._extensions.forEach(factory => {
+      const ext = factory.factory({
+        path: this._widgetAdapter.widget.context.path,
+        editor: editor,
+        widgetAdapter: this._widgetAdapter,
+        model: codeEditor.model,
+        inline: true
+      });
+
+      if (!ext) {
+        return;
+      }
+
+      codeEditor.injectExtension(ext.instance(codeEditor));
+    });
+  }
+
+  private _widgetAdapter: WidgetLSPAdapter<any>;
+  private _extensions: EditorAdapter.ILSPEditorExtensionFactory[];
+}
+
+/**
+ * A namespace for EditorAdapter `statics`.
+ */
+export namespace EditorAdapter {
+  /**
+   * Instantiation options for `EditorAdapter`.
+   */
+  export interface IOptions {
+    /**
+     * Editor wrapper enabling revealing the editor when detached (out of view).
+     */
+    editor: Document.IEditor;
+
+    /**
+     * The widget lsp adapter.
+     */
+    widgetAdapter: WidgetLSPAdapter;
+
+    /**
+     * The list of CodeMirror extension factories
+     */
+    extensions: ILSPEditorExtensionFactory[];
+  }
+
+  export interface ILSPEditorExtensionFactory
+    extends Omit<IEditorExtensionFactory<any>, 'factory'> {
+    /**
+     * Extension factory.
+     *
+     * @param options
+     * @returns The extension builder or null if the extension is not active for that document
+     */
+    readonly factory: (
+      options: IFactoryOptions
+    ) => IConfigurableExtension<any> | null;
+  }
+
+  export interface IFactoryOptions extends IEditorExtensionFactory.IOptions {
+    /**
+     * A path to a source file.
+     */
+    path: string;
+    /**
+     * The code editor.
+     */
+    editor: Document.IEditor;
+    /**
+     * The widget lsp adapter.
+     */
+    widgetAdapter: WidgetLSPAdapter<any>;
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,6 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+export * from './adapter';
+export * from './editorAdapter';
+export * from './tracker';

package/src/adapters/tracker.ts

@@ -0,0 +1,222 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { DocumentWidget } from '@jupyterlab/docregistry';
+
+import { ISignal, Signal } from '@lumino/signaling';
+
+import { WidgetLSPAdapter } from './adapter';
+import { IShell, IWidgetLSPAdapterTracker } from '../tokens';
+
+/**
+ * A class that keeps track of widget adapter instances.
+ *
+ * @typeparam T - The type of widget being tracked. Defaults to `WidgetLSPAdapter`.
+ */
+export class WidgetLSPAdapterTracker<
+  T extends WidgetLSPAdapter = WidgetLSPAdapter
+> implements IWidgetLSPAdapterTracker<T>
+{
+  /**
+   * Create a new widget tracker.
+   *
+   * @param options - The instantiation options for a widget tracker.
+   */
+  constructor(options: WidgetLSPAdapterTracker.IOptions) {
+    const shell = (this._shell = options.shell);
+
+    shell.currentChanged.connect((_, args) => {
+      let newValue = args.newValue;
+
+      if (!newValue || !(newValue instanceof DocumentWidget)) {
+        console.log('No current widget');
+        return;
+      }
+
+      const adapter = this.find(value => value.widget === newValue);
+
+      if (!adapter) {
+        return;
+      }
+
+      this._current = adapter;
+      this._currentChanged.emit(adapter);
+    });
+  }
+
+  /**
+   * A signal emitted when the current adapter changes.
+   */
+  get currentChanged(): ISignal<this, T | null> {
+    return this._currentChanged;
+  }
+
+  /**
+   * The current adapter is the most recently focused or added adapter.
+   *
+   * #### Notes
+   * It is the most recently focused adapter, or the most recently added
+   * adapter if no adapter has taken focus.
+   */
+  get currentAdapter(): T | null {
+    return this._current;
+  }
+
+  /**
+   * The number of adapter held by the tracker.
+   */
+  get size(): number {
+    return this._adapters.size;
+  }
+
+  /**
+   * A signal emitted when an adapter is added.
+   */
+  get adapterAdded(): ISignal<this, T> {
+    return this._adapterAdded;
+  }
+
+  /**
+   * A signal emitted when an adapter is updated.
+   */
+  get adapterUpdated(): ISignal<this, T> {
+    return this._adapterUpdated;
+  }
+
+  /**
+   * Add a new adapter to the tracker.
+   *
+   * @param adapter - The adapter being added.
+   *
+   * #### Notes.
+   * The newly added adapter becomes the current adapter unless the shell
+   * already had a DocumentWidget as the activeWidget.
+   */
+  add(adapter: T): void {
+    if (adapter.isDisposed) {
+      const warning = 'A disposed object cannot be added.';
+      console.warn(warning, adapter);
+      throw new Error(warning);
+    }
+
+    if (this._adapters.has(adapter)) {
+      const warning = 'This object already exists in the pool.';
+      console.warn(warning, adapter);
+      throw new Error(warning);
+    }
+
+    this._adapters.add(adapter);
+    this._adapterAdded.emit(adapter);
+
+    adapter.disposed.connect(() => {
+      this._adapters.delete(adapter);
+
+      if (adapter === this._current) {
+        this._current = null;
+        this._currentChanged.emit(this._current);
+      }
+    }, this);
+
+    // Only update the current adapter, when there is no shell.activeWidget
+    // or the active widget is not a DocumentWidget
+    // We will be able to use other panels while keeping the current adapter.
+    const active = this._shell.activeWidget;
+    if (!active || !(active instanceof DocumentWidget)) {
+      this._current = adapter;
+      this._currentChanged.emit(adapter);
+    }
+  }
+
+  /**
+   * Test whether the tracker is disposed.
+   */
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  /**
+   * Dispose of the resources held by the tracker.
+   */
+  dispose(): void {
+    if (this.isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this._adapters.clear();
+    Signal.clearData(this);
+  }
+
+  /**
+   * Find the first adapter in the tracker that satisfies a filter function.
+   *
+   * @param - fn The filter function to call on each adapter.
+   *
+   * #### Notes
+   * If no adapter is found, the value returned is `undefined`.
+   */
+  find(fn: (adapter: T) => boolean): T | undefined {
+    const values = this._adapters.values();
+    for (const value of values) {
+      if (fn(value)) {
+        return value;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Iterate through each adapter in the tracker.
+   *
+   * @param fn - The function to call on each adapter.
+   */
+  forEach(fn: (adapter: T) => void): void {
+    this._adapters.forEach(fn);
+  }
+
+  /**
+   * Filter the adapter in the tracker based on a predicate.
+   *
+   * @param fn - The function by which to filter.
+   */
+  filter(fn: (adapter: T) => boolean): T[] {
+    const filtered: T[] = [];
+    this.forEach(value => {
+      if (fn(value)) {
+        filtered.push(value);
+      }
+    });
+    return filtered;
+  }
+
+  /**
+   * Check if this tracker has the specified adapter.
+   *
+   * @param adapter - The adapter whose existence is being checked.
+   */
+  has(adapter: T): boolean {
+    return this._adapters.has(adapter);
+  }
+
+  private _isDisposed = false;
+  private _shell: IShell;
+  private _current: T | null = null;
+  private _adapters = new Set<T>();
+  private _adapterAdded = new Signal<this, T>(this);
+  private _adapterUpdated = new Signal<this, T>(this);
+  private _currentChanged = new Signal<this, T | null>(this);
+}
+
+/**
+ * A namespace for `WidgetLSPAdapterTracker` statics.
+ */
+export namespace WidgetLSPAdapterTracker {
+  /**
+   * The instantiation options for the WidgetLSPAdapterTracker.
+   */
+  export interface IOptions {
+    /**
+     * The JupyterLab shell for tracking all widgets.
+     */
+    shell: IShell;
+  }
+}

package/src/connection_manager.ts

@@ -2,10 +2,9 @@
 // Distributed under the terms of the Modified BSD License.
 
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
-import { IDocumentWidget } from '@jupyterlab/docregistry';
 import { ISignal, Signal } from '@lumino/signaling';
 
-import { WidgetLSPAdapter } from './adapters/adapter';
+import { WidgetLSPAdapter } from './adapters';
 import { LSPConnection } from './connection';
 import { ClientCapabilities } from './lsp';
 import { AskServersToSendTraceNotifications } from './plugin';
@@ -16,6 +15,7 @@ import {
   ILSPConnection,
   ILSPDocumentConnectionManager,
   ISocketConnectionOptions,
+  IWidgetLSPAdapterTracker,
   TLanguageServerConfigurations,
   TLanguageServerId,
   TServerKeys
@@ -40,6 +40,11 @@ export class DocumentConnectionManager
     this._ignoredLanguages = new Set();
     this.languageServerManager = options.languageServerManager;
     Private.setLanguageServerManager(options.languageServerManager);
+
+    options.adapterTracker.adapterAdded.connect((_, adapter) => {
+      const path = adapter.widget.context.path;
+      this.registerAdapter(path, adapter);
+    });
   }
 
   /**
@@ -49,9 +54,10 @@ export class DocumentConnectionManager
   readonly connections: Map<VirtualDocument.uri, LSPConnection>;
 
   /**
+   * @deprecated
    * Map between the path of the document and its adapter
    */
-  readonly adapters: Map<string, WidgetLSPAdapter<IDocumentWidget>>;
+  readonly adapters: Map<string, WidgetLSPAdapter>;
 
   /**
    * Map between the URI of the virtual document and the document itself.
@@ -199,16 +205,21 @@ export class DocumentConnectionManager
   }
 
   /**
+   * @deprecated
+   *
    * Register a widget adapter with this manager
    *
    * @param  path - path to the inner document of the adapter
    * @param  adapter - the adapter to be registered
    */
-  registerAdapter(
-    path: string,
-    adapter: WidgetLSPAdapter<IDocumentWidget>
-  ): void {
+  registerAdapter(path: string, adapter: WidgetLSPAdapter): void {
     this.adapters.set(path, adapter);
+
+    adapter.widget.context.pathChanged.connect((context, newPath) => {
+      this.adapters.delete(path);
+      this.adapters.set(newPath, adapter);
+    });
+
     adapter.disposed.connect(() => {
       if (adapter.virtualDocument) {
         this.documents.delete(adapter.virtualDocument.uri);
@@ -535,6 +546,11 @@ export namespace DocumentConnectionManager {
      * The language server manager instance.
      */
     languageServerManager: ILanguageServerManager;
+
+    /**
+     * The WidgetLSPAdapter's tracker.
+     */
+    adapterTracker: IWidgetLSPAdapterTracker;
   }
 
   /**

package/src/feature.ts

@@ -6,13 +6,14 @@ import mergeWith from 'lodash.mergewith';
 
 import { ClientCapabilities } from './lsp';
 import { IFeature, ILSPFeatureManager } from './tokens';
+import { EditorAdapter } from './adapters/editorAdapter';
 
 /**
  * Class to manager the registered features of the language servers.
  */
 export class FeatureManager implements ILSPFeatureManager {
   constructor() {
-    this._featuresRegistered = new Signal(this);
+    this._featureRegistered = new Signal(this);
   }
   /**
    * List of registered features
@@ -22,8 +23,8 @@ export class FeatureManager implements ILSPFeatureManager {
   /**
    * Signal emitted when a new feature is registered.
    */
-  get featuresRegistered(): ISignal<ILSPFeatureManager, IFeature> {
-    return this._featuresRegistered;
+  get featureRegistered(): ISignal<ILSPFeatureManager, IFeature> {
+    return this._featureRegistered;
   }
 
   /**
@@ -36,7 +37,7 @@ export class FeatureManager implements ILSPFeatureManager {
       );
     } else {
       this.features.push(feature);
-      this._featuresRegistered.emit(feature);
+      this._featureRegistered.emit(feature);
     }
   }
 
@@ -54,5 +55,19 @@ export class FeatureManager implements ILSPFeatureManager {
     return capabilities;
   }
 
-  private _featuresRegistered: Signal<ILSPFeatureManager, IFeature>;
+  /**
+   * Get the extension factories of all clients.
+   */
+  extensionFactories(): EditorAdapter.ILSPEditorExtensionFactory[] {
+    const factories: EditorAdapter.ILSPEditorExtensionFactory[] = [];
+    for (const feature of this.features) {
+      if (!feature.extensionFactory) {
+        continue;
+      }
+      factories.push(feature.extensionFactory);
+    }
+    return factories;
+  }
+
+  private _featureRegistered: Signal<ILSPFeatureManager, IFeature>;
 }

package/src/index.ts

@@ -5,7 +5,7 @@
  * @module lsp
  */
 
-export * from './adapters/adapter';
+export * from './adapters';
 export * from './connection_manager';
 export * from './extractors';
 export * from './feature';

package/src/lsp.ts

@@ -5,6 +5,8 @@ import type * as lsp from 'vscode-languageserver-protocol';
 
 export type ClientCapabilities = lsp.ClientCapabilities;
 
+export type ServerCapabilities = lsp.ServerCapabilities;
+
 export enum DiagnosticSeverity {
   Error = 1,
   Warning = 2,