@jupyterlite/application 0.2.2 → 0.3.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyterlite/application",
-  "version": "0.2.2",
+  "version": "0.3.0-alpha.0",
   "description": "JupyterLite - Application",
   "homepage": "https://github.com/jupyterlite/jupyterlite",
   "bugs": {
@@ -27,7 +27,8 @@
     "lib/*.js.map",
     "lib/*.js",
     "style/*.css",
-    "style/index.js"
+    "style/index.js",
+    "src/**/*.{ts,tsx}"
   ],
   "scripts": {
     "build": "tsc -b",
@@ -37,23 +38,23 @@
     "watch": "tsc -b --watch"
   },
   "dependencies": {
-    "@jupyterlab/application": "~4.0.9",
-    "@jupyterlab/coreutils": "~6.0.9",
-    "@jupyterlab/docregistry": "~4.0.9",
-    "@jupyterlab/rendermime-interfaces": "~3.8.9",
+    "@jupyterlab/application": "~4.1.1",
+    "@jupyterlab/coreutils": "~6.1.1",
+    "@jupyterlab/docregistry": "~4.1.1",
+    "@jupyterlab/rendermime-interfaces": "~3.9.1",
     "@lumino/coreutils": "^2.1.2",
     "@lumino/signaling": "^2.1.2",
-    "@lumino/widgets": "^2.3.0"
+    "@lumino/widgets": "^2.3.1"
   },
   "devDependencies": {
     "@babel/core": "^7.11.6",
     "@babel/preset-env": "^7.12.1",
-    "@jupyterlab/testutils": "~4.0.9",
+    "@jupyterlab/testutils": "~4.1.1",
     "@types/jest": "^29.5.3",
     "jest": "^29.6.2",
     "rimraf": "~5.0.1",
     "ts-jest": "^29.1.1",
-    "typescript": "~5.0.4"
+    "typescript": "~5.1.6"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

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

package/src/singleWidgetApp.ts

@@ -0,0 +1,155 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { JupyterFrontEnd, JupyterFrontEndPlugin } from '@jupyterlab/application';
+
+import { createRendermimePlugins } from '@jupyterlab/application/lib/mimerenderers';
+
+import { LabStatus } from '@jupyterlab/application/lib/status';
+
+import { PageConfig } from '@jupyterlab/coreutils';
+
+import { IRenderMime } from '@jupyterlab/rendermime-interfaces';
+
+import { ISingleWidgetShell, SingleWidgetShell } from './singleWidgetShell';
+
+/**
+ * App is the main application class. It is instantiated once and shared.
+ */
+export class SingleWidgetApp extends JupyterFrontEnd<ISingleWidgetShell> {
+  /**
+   * Construct a new SingleWidgetApp object.
+   *
+   * @param options The instantiation options for an application.
+   */
+  constructor(options: SingleWidgetApp.IOptions = { shell: new SingleWidgetShell() }) {
+    super({
+      ...options,
+      shell: options.shell ?? new SingleWidgetShell(),
+    });
+    if (options.mimeExtensions) {
+      for (const plugin of createRendermimePlugins(options.mimeExtensions)) {
+        this.registerPlugin(plugin);
+      }
+    }
+  }
+
+  /**
+   * The name of the application.
+   */
+  readonly name = 'Single Widget Application';
+
+  /**
+   * A namespace/prefix plugins may use to denote their provenance.
+   */
+  readonly namespace = this.name;
+
+  /**
+   * The application busy and dirty status signals and flags.
+   */
+  readonly status = new LabStatus(this);
+
+  /**
+   * The version of the application.
+   */
+  readonly version = PageConfig.getOption('appVersion') ?? 'unknown';
+
+  /**
+   * The JupyterLab application paths dictionary.
+   */
+  get paths(): JupyterFrontEnd.IPaths {
+    return {
+      urls: {
+        base: PageConfig.getOption('baseUrl'),
+        notFound: PageConfig.getOption('notFoundUrl'),
+        app: PageConfig.getOption('appUrl'),
+        static: PageConfig.getOption('staticUrl'),
+        settings: PageConfig.getOption('settingsUrl'),
+        themes: PageConfig.getOption('themesUrl'),
+        doc: PageConfig.getOption('docUrl'),
+        translations: PageConfig.getOption('translationsApiUrl'),
+        hubHost: PageConfig.getOption('hubHost') || undefined,
+        hubPrefix: PageConfig.getOption('hubPrefix') || undefined,
+        hubUser: PageConfig.getOption('hubUser') || undefined,
+        hubServerName: PageConfig.getOption('hubServerName') || undefined,
+      },
+      directories: {
+        appSettings: PageConfig.getOption('appSettingsDir'),
+        schemas: PageConfig.getOption('schemasDir'),
+        static: PageConfig.getOption('staticDir'),
+        templates: PageConfig.getOption('templatesDir'),
+        themes: PageConfig.getOption('themesDir'),
+        userSettings: PageConfig.getOption('userSettingsDir'),
+        serverRoot: PageConfig.getOption('serverRoot'),
+        workspaces: PageConfig.getOption('workspacesDir'),
+      },
+    };
+  }
+
+  /**
+   * Register plugins from a plugin module.
+   *
+   * @param mod - The plugin module to register.
+   */
+  registerPluginModule(mod: SingleWidgetApp.IPluginModule): void {
+    let data = mod.default;
+    // Handle commonjs exports.
+    if (!Object.prototype.hasOwnProperty.call(mod, '__esModule')) {
+      data = mod as any;
+    }
+    if (!Array.isArray(data)) {
+      data = [data];
+    }
+    data.forEach((item) => {
+      try {
+        this.registerPlugin(item);
+      } catch (error) {
+        console.error(error);
+      }
+    });
+  }
+
+  /**
+   * Register the plugins from multiple plugin modules.
+   *
+   * @param mods - The plugin modules to register.
+   */
+  registerPluginModules(mods: SingleWidgetApp.IPluginModule[]): void {
+    mods.forEach((mod) => {
+      this.registerPluginModule(mod);
+    });
+  }
+}
+
+/**
+ * A namespace for App statics.
+ */
+export namespace SingleWidgetApp {
+  /**
+   * The instantiation options for an App application.
+   */
+  export interface IOptions
+    extends JupyterFrontEnd.IOptions<ISingleWidgetShell>,
+      Partial<IInfo> {}
+
+  /**
+   * The information about a Jupyter Notebook application.
+   */
+  export interface IInfo {
+    /**
+     * The mime renderer extensions.
+     */
+    readonly mimeExtensions: IRenderMime.IExtensionModule[];
+  }
+
+  /**
+   * The interface for a module that exports a plugin or plugins as
+   * the default value.
+   */
+  export interface IPluginModule {
+    /**
+     * The default export.
+     */
+    default: JupyterFrontEndPlugin<any> | JupyterFrontEndPlugin<any>[];
+  }
+}

package/src/singleWidgetShell.ts

@@ -0,0 +1,121 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { JupyterFrontEnd } from '@jupyterlab/application';
+
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+
+import { find } from '@lumino/algorithm';
+
+import { Token } from '@lumino/coreutils';
+
+import { ISignal, Signal } from '@lumino/signaling';
+
+import { Panel, Widget, PanelLayout } from '@lumino/widgets';
+
+/**
+ * The single widget application shell token.
+ */
+export const ISingleWidgetShell = new Token<ISingleWidgetShell>(
+  '@jupyterlite/application:ISingleWidgetShell',
+);
+
+/**
+ * The single widget application shell interface.
+ */
+export interface ISingleWidgetShell extends SingleWidgetShell {}
+
+/**
+ * The application shell.
+ */
+export class SingleWidgetShell extends Widget implements JupyterFrontEnd.IShell {
+  constructor() {
+    super();
+    this.id = 'main';
+
+    const rootLayout = new PanelLayout();
+    this._main = new Panel();
+    this._main.id = 'single-widget-panel';
+    rootLayout.addWidget(this._main);
+    this.layout = rootLayout;
+  }
+
+  /**
+   * A signal emitted when the current widget changes.
+   */
+  get currentChanged(): ISignal<ISingleWidgetShell, void> {
+    return this._currentChanged;
+  }
+
+  /**
+   * The current widget in the shell's main area.
+   */
+  get currentWidget(): Widget | null {
+    return this._main.widgets[0] ?? null;
+  }
+
+  /**
+   * Activate a widget in its area.
+   */
+  activateById(id: string): void {
+    const widget = find(this.widgets('main'), (w) => w.id === id);
+    if (widget) {
+      widget.activate();
+    }
+  }
+
+  /**
+   * Add a widget to the application shell.
+   *
+   * @param widget - The widget being added.
+   *
+   * @param area - Optional region in the shell into which the widget should
+   * be added.
+   *
+   * @param options - Optional open options.
+   *
+   */
+  add(
+    widget: Widget,
+    area?: Shell.Area,
+    options?: DocumentRegistry.IOpenOptions,
+  ): void {
+    if (area === 'main' || area === undefined) {
+      if (this._main.widgets.length > 0) {
+        // do not add the widget if there is already one
+        return;
+      }
+      this._main.addWidget(widget);
+      this._main.update();
+      this._currentChanged.emit(void 0);
+    }
+  }
+
+  /**
+   * Return the list of widgets for the given area.
+   *
+   * @param area The area
+   */
+  *widgets(area: Shell.Area): IterableIterator<Widget> {
+    switch (area ?? 'main') {
+      case 'main':
+        yield* this._main.widgets;
+        break;
+      default:
+        throw new Error(`Invalid area: ${area}`);
+    }
+  }
+
+  private _main: Panel;
+  private _currentChanged = new Signal<this, void>(this);
+}
+
+/**
+ * A namespace for Shell statics
+ */
+export namespace Shell {
+  /**
+   * The areas of the application shell where widgets can reside.
+   */
+  export type Area = 'main';
+}