@jupyterlab/apputils-extension 4.0.0-alpha.9 → 4.0.0-beta.0

package/src/palette.ts

@@ -0,0 +1,213 @@
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+import { ILayoutRestorer, JupyterFrontEnd } from '@jupyterlab/application';
+import {
+  ICommandPalette,
+  IPaletteItem,
+  ModalCommandPalette
+} from '@jupyterlab/apputils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { CommandPaletteSvg, paletteIcon } from '@jupyterlab/ui-components';
+import { find } from '@lumino/algorithm';
+import { CommandRegistry } from '@lumino/commands';
+import { DisposableDelegate, IDisposable } from '@lumino/disposable';
+import { CommandPalette } from '@lumino/widgets';
+
+/**
+ * The command IDs used by the apputils extension.
+ */
+namespace CommandIDs {
+  export const activate = 'apputils:activate-command-palette';
+}
+
+const PALETTE_PLUGIN_ID = '@jupyterlab/apputils-extension:palette';
+
+/**
+ * A thin wrapper around the `CommandPalette` class to conform with the
+ * JupyterLab interface for the application-wide command palette.
+ */
+export class Palette implements ICommandPalette {
+  /**
+   * Create a palette instance.
+   */
+  constructor(palette: CommandPalette, translator?: ITranslator) {
+    this.translator = translator || nullTranslator;
+    const trans = this.translator.load('jupyterlab');
+    this._palette = palette;
+    this._palette.title.label = '';
+    this._palette.title.caption = trans.__('Command Palette');
+  }
+
+  /**
+   * The placeholder text of the command palette's search input.
+   */
+  set placeholder(placeholder: string) {
+    this._palette.inputNode.placeholder = placeholder;
+  }
+  get placeholder(): string {
+    return this._palette.inputNode.placeholder;
+  }
+
+  /**
+   * Activate the command palette for user input.
+   */
+  activate(): void {
+    this._palette.activate();
+  }
+
+  /**
+   * Add a command item to the command palette.
+   *
+   * @param options - The options for creating the command item.
+   *
+   * @returns A disposable that will remove the item from the palette.
+   */
+  addItem(options: IPaletteItem): IDisposable {
+    const item = this._palette.addItem(options as CommandPalette.IItemOptions);
+    return new DisposableDelegate(() => {
+      this._palette.removeItem(item);
+    });
+  }
+
+  protected translator: ITranslator;
+  private _palette: CommandPalette;
+}
+
+/**
+ * A namespace for `Palette` statics.
+ */
+export namespace Palette {
+  /**
+   * Activate the command palette.
+   */
+  export function activate(
+    app: JupyterFrontEnd,
+    translator: ITranslator,
+    settingRegistry: ISettingRegistry | null
+  ): ICommandPalette {
+    const { commands, shell } = app;
+    const trans = translator.load('jupyterlab');
+    const palette = Private.createPalette(app, translator);
+    const modalPalette = new ModalCommandPalette({ commandPalette: palette });
+    let modal = false;
+
+    palette.node.setAttribute('role', 'region');
+    palette.node.setAttribute(
+      'aria-label',
+      trans.__('Command Palette Section')
+    );
+    shell.add(palette, 'left', { rank: 300, type: 'Command Palette' });
+    if (settingRegistry) {
+      const loadSettings = settingRegistry.load(PALETTE_PLUGIN_ID);
+      const updateSettings = (settings: ISettingRegistry.ISettings): void => {
+        const newModal = settings.get('modal').composite as boolean;
+        if (modal && !newModal) {
+          palette.parent = null;
+          modalPalette.detach();
+          shell.add(palette, 'left', { rank: 300, type: 'Command Palette' });
+        } else if (!modal && newModal) {
+          palette.parent = null;
+          modalPalette.palette = palette;
+          palette.show();
+          modalPalette.attach();
+        }
+        modal = newModal;
+      };
+
+      Promise.all([loadSettings, app.restored])
+        .then(([settings]) => {
+          updateSettings(settings);
+          settings.changed.connect(settings => {
+            updateSettings(settings);
+          });
+        })
+        .catch((reason: Error) => {
+          console.error(reason.message);
+        });
+    }
+
+    // Show the current palette shortcut in its title.
+    const updatePaletteTitle = () => {
+      const binding = find(
+        app.commands.keyBindings,
+        b => b.command === CommandIDs.activate
+      );
+      if (binding) {
+        const ks = binding.keys.map(CommandRegistry.formatKeystroke).join(', ');
+        palette.title.caption = trans.__('Commands (%1)', ks);
+      } else {
+        palette.title.caption = trans.__('Commands');
+      }
+    };
+    updatePaletteTitle();
+    app.commands.keyBindingChanged.connect(() => {
+      updatePaletteTitle();
+    });
+
+    commands.addCommand(CommandIDs.activate, {
+      execute: () => {
+        if (modal) {
+          modalPalette.activate();
+        } else {
+          shell.activateById(palette.id);
+        }
+      },
+      label: trans.__('Activate Command Palette')
+    });
+
+    palette.inputNode.placeholder = trans.__('SEARCH');
+
+    return new Palette(palette, translator);
+  }
+
+  /**
+   * Restore the command palette.
+   */
+  export function restore(
+    app: JupyterFrontEnd,
+    restorer: ILayoutRestorer,
+    translator: ITranslator
+  ): void {
+    const palette = Private.createPalette(app, translator);
+    // Let the application restorer track the command palette for restoration of
+    // application state (e.g. setting the command palette as the current side bar
+    // widget).
+    restorer.add(palette, 'command-palette');
+  }
+}
+
+/**
+ * The namespace for module private data.
+ */
+namespace Private {
+  /**
+   * The private command palette instance.
+   */
+  let palette: CommandPalette;
+
+  /**
+   * Create the application-wide command palette.
+   */
+  export function createPalette(
+    app: JupyterFrontEnd,
+    translator: ITranslator
+  ): CommandPalette {
+    if (!palette) {
+      // use a renderer tweaked to use inline svg icons
+      palette = new CommandPalette({
+        commands: app.commands,
+        renderer: CommandPaletteSvg.defaultRenderer
+      });
+      palette.id = 'command-palette';
+      palette.title.icon = paletteIcon;
+      const trans = translator.load('jupyterlab');
+      palette.title.label = trans.__('Commands');
+    }
+
+    return palette;
+  }
+}

package/src/settingconnector.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { PageConfig } from '@jupyterlab/coreutils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { DataConnector, IDataConnector } from '@jupyterlab/statedb';
+import { Throttler } from '@lumino/polling';
+
+/**
+ * A data connector for fetching settings.
+ *
+ * #### Notes
+ * This connector adds a query parameter to the base services setting manager.
+ */
+export class SettingConnector extends DataConnector<
+  ISettingRegistry.IPlugin,
+  string
+> {
+  constructor(connector: IDataConnector<ISettingRegistry.IPlugin, string>) {
+    super();
+    this._connector = connector;
+  }
+
+  /**
+   * Fetch settings for a plugin.
+   * @param id - The plugin ID
+   *
+   * #### Notes
+   * The REST API requests are throttled at one request per plugin per 100ms.
+   */
+  fetch(id: string): Promise<ISettingRegistry.IPlugin | undefined> {
+    const throttlers = this._throttlers;
+    if (!(id in throttlers)) {
+      throttlers[id] = new Throttler(() => this._connector.fetch(id), 100);
+    }
+    return throttlers[id].invoke();
+  }
+
+  async list(
+    query: 'active' | 'all' = 'all'
+  ): Promise<{ ids: string[]; values: ISettingRegistry.IPlugin[] }> {
+    const { isDeferred, isDisabled } = PageConfig.Extension;
+    const { ids, values } = await this._connector.list();
+
+    if (query === 'all') {
+      return { ids, values };
+    }
+
+    return {
+      ids: ids.filter(id => !isDeferred(id) && !isDisabled(id)),
+      values: values.filter(({ id }) => !isDeferred(id) && !isDisabled(id))
+    };
+  }
+
+  async save(id: string, raw: string): Promise<void> {
+    await this._connector.save(id, raw);
+  }
+
+  private _connector: IDataConnector<ISettingRegistry.IPlugin, string>;
+  private _throttlers: { [key: string]: Throttler } = Object.create(null);
+}

package/src/settingsplugin.ts

@@ -0,0 +1,65 @@
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import { PageConfig } from '@jupyterlab/coreutils';
+import { ISettingRegistry, SettingRegistry } from '@jupyterlab/settingregistry';
+import { SettingConnector } from './settingconnector';
+
+/**
+ * The default setting registry provider.
+ */
+export const settingsPlugin: JupyterFrontEndPlugin<ISettingRegistry> = {
+  id: '@jupyterlab/apputils-extension:settings',
+  activate: async (app: JupyterFrontEnd): Promise<ISettingRegistry> => {
+    const { isDisabled } = PageConfig.Extension;
+    const connector = new SettingConnector(app.serviceManager.settings);
+
+    // On startup, check if a plugin is available in the application.
+    // This helps avoid loading plugin files from other lab-based applications
+    // that have placed their schemas next to the JupyterLab schemas. Different lab-based
+    // applications might not have the same set of plugins loaded on the page.
+    // As an example this helps prevent having new toolbar items added by another application
+    // appear in JupyterLab as a side-effect when they are defined via the settings system.
+    const registry = new SettingRegistry({
+      connector,
+      plugins: (await connector.list('active')).values.filter(value =>
+        app.hasPlugin(value.id)
+      )
+    });
+
+    // If there are plugins that have schemas that are not in the setting
+    // registry after the application has restored, try to load them manually
+    // because otherwise, its settings will never become available in the
+    // setting registry.
+    void app.restored.then(async () => {
+      const plugins = await connector.list('all');
+      plugins.ids.forEach(async (id, index) => {
+        if (!app.hasPlugin(id) || isDisabled(id) || id in registry.plugins) {
+          return;
+        }
+
+        try {
+          await registry.load(id);
+        } catch (error) {
+          console.warn(`Settings failed to load for (${id})`, error);
+          if (plugins.values[index].schema['jupyter.lab.transform']) {
+            console.warn(
+              `This may happen if {autoStart: false} in (${id}) ` +
+                `or if it is one of the deferredExtensions in page config.`
+            );
+          }
+        }
+      });
+    });
+
+    return registry;
+  },
+  autoStart: true,
+  provides: ISettingRegistry
+};

package/src/statusbarplugin.ts

@@ -0,0 +1,145 @@
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+import {
+  ILabShell,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import {
+  IKernelStatusModel,
+  ISessionContext,
+  ISessionContextDialogs,
+  KernelStatus,
+  RunningSessions,
+  SessionContextDialogs
+} from '@jupyterlab/apputils';
+import { IStatusBar } from '@jupyterlab/statusbar';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { Title, Widget } from '@lumino/widgets';
+
+/**
+ * A plugin that provides a kernel status item to the status bar.
+ */
+export const kernelStatus: JupyterFrontEndPlugin<IKernelStatusModel> = {
+  id: '@jupyterlab/apputils-extension:kernel-status',
+  autoStart: true,
+  requires: [IStatusBar],
+  provides: IKernelStatusModel,
+  optional: [ISessionContextDialogs, ITranslator, ILabShell],
+  activate: (
+    app: JupyterFrontEnd,
+    statusBar: IStatusBar,
+    sessionDialogs_: ISessionContextDialogs | null,
+    translator_: ITranslator | null,
+    labShell: ILabShell | null
+  ): IKernelStatusModel => {
+    const translator = translator_ ?? nullTranslator;
+    const sessionDialogs =
+      sessionDialogs_ ?? new SessionContextDialogs({ translator });
+    // When the status item is clicked, launch the kernel
+    // selection dialog for the current session.
+    const changeKernel = async () => {
+      if (!item.model.sessionContext) {
+        return;
+      }
+      await sessionDialogs.selectKernel(item.model.sessionContext);
+    };
+
+    // Create the status item.
+    const item = new KernelStatus({ onClick: changeKernel }, translator);
+
+    const providers = new Set<(w: Widget | null) => ISessionContext | null>();
+
+    const addSessionProvider = (
+      provider: (w: Widget | null) => ISessionContext | null
+    ): void => {
+      providers.add(provider);
+
+      if (app.shell.currentWidget) {
+        updateSession(app.shell, {
+          newValue: app.shell.currentWidget,
+          oldValue: null
+        });
+      }
+    };
+
+    function updateSession(
+      shell: JupyterFrontEnd.IShell,
+      changes: ILabShell.IChangedArgs
+    ) {
+      const { oldValue, newValue } = changes;
+
+      // Clean up after the old value if it exists,
+      // listen for changes to the title of the activity
+      if (oldValue) {
+        oldValue.title.changed.disconnect(onTitleChanged);
+      }
+
+      item.model.sessionContext =
+        [...providers]
+          .map(provider => provider(changes.newValue))
+          .filter(session => session !== null)[0] ?? null;
+
+      if (newValue && item.model.sessionContext) {
+        onTitleChanged(newValue.title);
+        newValue.title.changed.connect(onTitleChanged);
+      }
+    }
+
+    // When the title of the active widget changes, update the label
+    // of the hover text.
+    const onTitleChanged = (title: Title<Widget>) => {
+      item.model!.activityName = title.label;
+    };
+
+    if (labShell) {
+      labShell.currentChanged.connect(updateSession);
+    }
+
+    statusBar.registerStatusItem(kernelStatus.id, {
+      item,
+      align: 'left',
+      rank: 1,
+      isActive: () => item.model!.sessionContext !== null
+    });
+
+    return { addSessionProvider };
+  }
+};
+
+/*
+ * A plugin providing running terminals and sessions information
+ * to the status bar.
+ */
+export const runningSessionsStatus: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlab/apputils-extension:running-sessions-status',
+  autoStart: true,
+  requires: [IStatusBar, ITranslator],
+  activate: (
+    app: JupyterFrontEnd,
+    statusBar: IStatusBar,
+    translator: ITranslator
+  ) => {
+    const item = new RunningSessions({
+      onClick: () => app.shell.activateById('jp-running-sessions'),
+      serviceManager: app.serviceManager,
+      translator
+    });
+
+    item.model.sessions = Array.from(
+      app.serviceManager.sessions.running()
+    ).length;
+    item.model.terminals = Array.from(
+      app.serviceManager.terminals.running()
+    ).length;
+
+    statusBar.registerStatusItem(runningSessionsStatus.id, {
+      item,
+      align: 'left',
+      rank: 0
+    });
+  }
+};