jupyter-specta 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Duc Trung Le
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# specta

package/lib/app.d.ts

@@ -0,0 +1,61 @@
+import { JupyterFrontEnd, JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { SpectaShell } from './shell';
+import { IRenderMime } from '@jupyterlab/rendermime';
+export declare class SpectaApp extends JupyterFrontEnd<SpectaShell> {
+    constructor(options: SpectaApp.IOptions);
+    /**
+     * The name of the application.
+     */
+    readonly name: string;
+    /**
+     * A namespace/prefix plugins may use to denote their provenance.
+     */
+    readonly namespace: string;
+    /**
+     * The version of the application.
+     */
+    readonly version = "1.0.0";
+    /**
+     * The JupyterLab application paths dictionary.
+     */
+    get paths(): JupyterFrontEnd.IPaths;
+    /**
+     * Register plugins from a plugin module.
+     *
+     * @param mod - The plugin module to register.
+     */
+    registerPluginModule(mod: SpectaApp.IPluginModule): void;
+    /**
+     * Register the plugins from multiple plugin modules.
+     *
+     * @param mods - The plugin modules to register.
+     */
+    registerPluginModules(mods: SpectaApp.IPluginModule[]): void;
+}
+export declare namespace SpectaApp {
+    /**
+     * The instantiation options for an App application.
+     */
+    interface IOptions extends JupyterFrontEnd.IOptions<SpectaShell>, Partial<IInfo> {
+        paths?: Partial<JupyterFrontEnd.IPaths>;
+    }
+    /**
+     * The information about a Specta application.
+     */
+    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.
+     */
+    interface IPluginModule {
+        /**
+         * The default export.
+         */
+        default: JupyterFrontEndPlugin<any> | JupyterFrontEndPlugin<any>[];
+    }
+}

package/lib/app.js

@@ -0,0 +1,90 @@
+import { JupyterFrontEnd, createRendermimePlugins } from '@jupyterlab/application';
+import { SpectaShell } from './shell';
+import { PageConfig } from '@jupyterlab/coreutils';
+export class SpectaApp extends JupyterFrontEnd {
+    constructor(options) {
+        var _a;
+        super(Object.assign(Object.assign({}, options), { shell: (_a = options.shell) !== null && _a !== void 0 ? _a : new SpectaShell() }));
+        /**
+         * The name of the application.
+         */
+        this.name = 'Voila';
+        /**
+         * A namespace/prefix plugins may use to denote their provenance.
+         */
+        this.namespace = this.name;
+        /**
+         * The version of the application.
+         */
+        this.version = '1.0.0';
+        if (options.mimeExtensions) {
+            for (const plugin of createRendermimePlugins(options.mimeExtensions)) {
+                this.registerPlugin(plugin);
+            }
+        }
+    }
+    /**
+     * The JupyterLab application paths dictionary.
+     */
+    get paths() {
+        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) {
+        let data = mod.default;
+        // Handle commonjs exports.
+        if (!Object.prototype.hasOwnProperty.call(mod, '__esModule')) {
+            data = mod;
+        }
+        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) {
+        mods.forEach(mod => {
+            this.registerPluginModule(mod);
+        });
+    }
+}

package/lib/create_notebook_panel.d.ts

@@ -0,0 +1,9 @@
+import { IEditorServices } from '@jupyterlab/codeeditor';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { INotebookModel, NotebookPanel } from '@jupyterlab/notebook';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+export declare function createNotebookPanel(options: {
+    context: DocumentRegistry.IContext<INotebookModel>;
+    rendermime: IRenderMimeRegistry;
+    editorServices: IEditorServices;
+}): NotebookPanel;

package/lib/create_notebook_panel.js

@@ -0,0 +1,14 @@
+import { Notebook, NotebookPanel } from '@jupyterlab/notebook';
+export function createNotebookPanel(options) {
+    const { context, rendermime, editorServices } = options;
+    const editorFactory = editorServices.factoryService.newInlineEditor;
+    const content = new Notebook({
+        rendermime,
+        contentFactory: new Notebook.ContentFactory({ editorFactory }),
+        mimeTypeService: editorServices.mimeTypeService
+    });
+    return new NotebookPanel({
+        content,
+        context
+    });
+}

package/lib/document/factory.d.ts

@@ -0,0 +1,13 @@
+import { ABCWidgetFactory, DocumentRegistry } from '@jupyterlab/docregistry';
+import { NotebookSpectaDocWidget } from './widget';
+import { INotebookModel } from '@jupyterlab/notebook';
+import { SpectaWidgetFactory } from '../specta_widget_factory';
+interface IOptions extends DocumentRegistry.IWidgetFactoryOptions {
+    spectaWidgetFactory: SpectaWidgetFactory;
+}
+export declare class NotebookGridWidgetFactory extends ABCWidgetFactory<NotebookSpectaDocWidget, INotebookModel> {
+    constructor(options: IOptions);
+    protected createNewWidget(context: DocumentRegistry.IContext<INotebookModel>): NotebookSpectaDocWidget;
+    private _spectaWidgetFactory;
+}
+export {};

package/lib/document/factory.js

@@ -0,0 +1,26 @@
+import { ABCWidgetFactory } from '@jupyterlab/docregistry';
+import { NotebookSpectaDocWidget } from './widget';
+import { Widget } from '@lumino/widgets';
+export class NotebookGridWidgetFactory extends ABCWidgetFactory {
+    constructor(options) {
+        super(options);
+        this._spectaWidgetFactory = options.spectaWidgetFactory;
+    }
+    createNewWidget(context) {
+        const content = new Widget();
+        content.addClass('jp-specta-notebook-panel');
+        context.ready.then(async () => {
+            const spectaWidget = await this._spectaWidgetFactory.createNew({
+                context
+            });
+            if (spectaWidget) {
+                Widget.attach(spectaWidget, content.node);
+            }
+        });
+        const widget = new NotebookSpectaDocWidget({
+            context,
+            content
+        });
+        return widget;
+    }
+}

package/lib/document/plugin.d.ts

@@ -0,0 +1,4 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+export declare const spectaDocument: JupyterFrontEndPlugin<IWidgetTracker>;
+export declare const spectaOpener: JupyterFrontEndPlugin<void>;

package/lib/document/plugin.js

@@ -0,0 +1,60 @@
+import { WidgetTracker } from '@jupyterlab/apputils';
+import { IEditorServices } from '@jupyterlab/codeeditor';
+import { INotebookTracker, NotebookPanel } from '@jupyterlab/notebook';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { createFileBrowser, hideAppLoadingIndicator, isSpectaApp, registerDocumentFactory } from '../tool';
+import { ISpectaDocTracker, ISpectaLayoutRegistry } from '../token';
+import { IKernelSpecManager } from '@jupyterlab/services';
+const activate = (app, rendermime, tracker, editorServices, contentFactory, spectaLayoutRegistry) => {
+    const namespace = 'specta';
+    const spectaTracker = new WidgetTracker({ namespace });
+    registerDocumentFactory({
+        factoryName: 'specta',
+        app,
+        rendermime,
+        tracker,
+        editorServices,
+        contentFactory,
+        spectaTracker,
+        spectaLayoutRegistry
+    });
+    return spectaTracker;
+};
+export const spectaDocument = {
+    id: 'specta:notebook-doc',
+    autoStart: true,
+    requires: [
+        IRenderMimeRegistry,
+        INotebookTracker,
+        IEditorServices,
+        NotebookPanel.IContentFactory,
+        ISpectaLayoutRegistry
+    ],
+    activate,
+    provides: ISpectaDocTracker
+};
+export const spectaOpener = {
+    id: 'specta/application-extension:opener',
+    autoStart: true,
+    requires: [IDocumentManager, ISpectaDocTracker, IKernelSpecManager],
+    activate: async (app, docManager) => {
+        if (!isSpectaApp()) {
+            // Not a specta app, return
+            return;
+        }
+        const urlParams = new URLSearchParams(window.location.search);
+        const path = urlParams.get('path');
+        if (!path) {
+            const browser = createFileBrowser({ docManager });
+            app.shell.add(browser, 'main', { rank: 100 });
+            hideAppLoadingIndicator();
+        }
+        else {
+            const widget = docManager.openOrReveal(path, 'specta');
+            if (widget) {
+                app.shell.add(widget, 'main');
+            }
+        }
+    }
+};

package/lib/document/widget.d.ts

@@ -0,0 +1,17 @@
+import { IEditorMimeTypeService } from '@jupyterlab/codeeditor';
+import { DocumentWidget } from '@jupyterlab/docregistry';
+import { INotebookModel, INotebookTracker, NotebookPanel } from '@jupyterlab/notebook';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { ServiceManager } from '@jupyterlab/services';
+import { Widget } from '@lumino/widgets';
+export interface ISpectaOptions {
+    manager: ServiceManager;
+    rendermime: IRenderMimeRegistry;
+    tracker: INotebookTracker;
+    contentFactory: NotebookPanel.IContentFactory;
+    mimeTypeService: IEditorMimeTypeService;
+}
+export declare class NotebookSpectaDocWidget extends DocumentWidget<Widget, INotebookModel> {
+    constructor(options: DocumentWidget.IOptions<Widget, INotebookModel>);
+    dispose(): void;
+}

package/lib/document/widget.js

@@ -0,0 +1,10 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
+export class NotebookSpectaDocWidget extends DocumentWidget {
+    constructor(options) {
+        super(options);
+    }
+    dispose() {
+        this.content.dispose();
+        super.dispose();
+    }
+}

package/lib/extension_plugins.d.ts

@@ -0,0 +1,4 @@
+export * from './tool';
+export * from './token';
+declare const _default: (import("@jupyterlab/application").JupyterFrontEndPlugin<import("@jupyterlab/apputils").IWidgetTracker<import("@lumino/widgets").Widget>> | import("@jupyterlab/application").JupyterFrontEndPlugin<void> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("./token").ISpectaLayoutRegistry>)[];
+export default _default;

package/lib/extension_plugins.js

@@ -0,0 +1,5 @@
+import { spectaDocument, spectaOpener } from './document/plugin';
+import { spectaLayoutRegistry } from './layout/plugin';
+export * from './tool';
+export * from './token';
+export default [spectaDocument, spectaOpener, spectaLayoutRegistry];

package/lib/layout/default.d.ts

@@ -0,0 +1,12 @@
+import { Panel } from '@lumino/widgets';
+import { SpectaCellOutput } from '../specta_cell_output';
+import * as nbformat from '@jupyterlab/nbformat';
+import { ISpectaLayout } from '../token';
+export declare class DefaultLayout implements ISpectaLayout {
+    render(options: {
+        host: Panel;
+        items: SpectaCellOutput[];
+        notebook: nbformat.INotebookContent;
+        readyCallback: () => Promise<void>;
+    }): Promise<void>;
+}

package/lib/layout/default.js

@@ -0,0 +1,23 @@
+export class DefaultLayout {
+    async render(options) {
+        const { host, items, readyCallback } = options;
+        for (const el of items) {
+            const outputNode = el.cellOutput.node;
+            const cellModel = el.info.cellModel;
+            const info = el.info;
+            if ((cellModel === null || cellModel === void 0 ? void 0 : cellModel.cell_type) === 'code') {
+                if (outputNode.childNodes.length > 0) {
+                    if (!info.hidden) {
+                        host.addWidget(el);
+                    }
+                }
+            }
+            else {
+                if (!info.hidden) {
+                    host.addWidget(el);
+                }
+            }
+        }
+        await readyCallback();
+    }
+}

package/lib/layout/layout_registry.d.ts

@@ -0,0 +1,22 @@
+import { ISignal } from '@lumino/signaling';
+import { ISpectaLayout, ISpectaLayoutRegistry } from '../token';
+export declare class SpectaLayoutRegistry implements ISpectaLayoutRegistry {
+    constructor();
+    get layoutAdded(): ISignal<SpectaLayoutRegistry, string>;
+    get selectedLayout(): {
+        name: string;
+        layout: ISpectaLayout;
+    };
+    get selectedLayoutChanged(): ISignal<SpectaLayoutRegistry, {
+        name: string;
+        layout: ISpectaLayout;
+    }>;
+    get(name: string): ISpectaLayout | undefined;
+    setSelectedLayout(name: string): void;
+    register(name: string, layout: ISpectaLayout): void;
+    allLayouts(): string[];
+    private _selectedLayout;
+    private _registry;
+    private _layoutAdded;
+    private _selectedLayoutChanged;
+}

package/lib/layout/layout_registry.js

@@ -0,0 +1,44 @@
+import { Signal } from '@lumino/signaling';
+import { DefaultLayout } from './default';
+export class SpectaLayoutRegistry {
+    constructor() {
+        this._registry = new Map();
+        this._layoutAdded = new Signal(this);
+        this._selectedLayoutChanged = new Signal(this);
+        const defaultLayout = new DefaultLayout();
+        this._registry = new Map();
+        this._registry.set('default', defaultLayout);
+        this._selectedLayout = {
+            name: 'default',
+            layout: defaultLayout
+        };
+    }
+    get layoutAdded() {
+        return this._layoutAdded;
+    }
+    get selectedLayout() {
+        return this._selectedLayout;
+    }
+    get selectedLayoutChanged() {
+        return this._selectedLayoutChanged;
+    }
+    get(name) {
+        return this._registry.get(name);
+    }
+    setSelectedLayout(name) {
+        if (!this._registry.has(name)) {
+            throw new Error(`Layout with name ${name} does not exist`);
+        }
+        this._selectedLayout = { name, layout: this._registry.get(name) };
+    }
+    register(name, layout) {
+        if (this._registry.has(name)) {
+            throw new Error(`Layout with name ${name} already exists`);
+        }
+        this._registry.set(name, layout);
+        this._layoutAdded.emit(name);
+    }
+    allLayouts() {
+        return Array.from(this._registry.keys());
+    }
+}

package/lib/layout/plugin.d.ts

@@ -0,0 +1,3 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { ISpectaLayoutRegistry } from '../token';
+export declare const spectaLayoutRegistry: JupyterFrontEndPlugin<ISpectaLayoutRegistry>;

package/lib/layout/plugin.js

@@ -0,0 +1,11 @@
+import { SpectaLayoutRegistry } from './layout_registry';
+import { ISpectaLayoutRegistry } from '../token';
+export const spectaLayoutRegistry = {
+    id: 'specta:layout-registry',
+    autoStart: true,
+    provides: ISpectaLayoutRegistry,
+    activate: (app) => {
+        const layoutRegistry = new SpectaLayoutRegistry();
+        return layoutRegistry;
+    }
+};

package/lib/plugins.d.ts

@@ -0,0 +1,2 @@
+declare const _default: never[];
+export default _default;

package/lib/plugins.js

@@ -0,0 +1,2 @@
+// Built-in plugins
+export default [];

package/lib/sharedscope.d.ts

@@ -0,0 +1,3 @@
+import '@jupyterlab/logconsole';
+import '@jupyterlite/server';
+import '@jupyterlab/console';

package/lib/sharedscope.js

@@ -0,0 +1,3 @@
+import '@jupyterlab/logconsole';
+import '@jupyterlite/server';
+import '@jupyterlab/console';

package/lib/shell.d.ts

@@ -0,0 +1,57 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Widget } from '@lumino/widgets';
+/**
+ * A namespace for Shell statics
+ */
+export declare namespace IShell {
+    /**
+     * The areas of the application shell where widgets can reside.
+     */
+    type Area = 'main' | 'header' | 'top' | 'menu' | 'left' | 'right' | 'bottom' | 'down';
+}
+/**
+ * The application shell.
+ */
+export declare class SpectaShell extends Widget implements JupyterFrontEnd.IShell {
+    constructor();
+    /**
+     * The current widget in the shell's main area.
+     */
+    get currentWidget(): Widget | null;
+    activateById(id: string): void;
+    /**
+     * 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.
+     *
+     */
+    add(widget: Widget, area?: IShell.Area, options?: DocumentRegistry.IOpenOptions): void;
+    widgets(area: IShell.Area): IterableIterator<Widget>;
+    /**
+     * Add a widget to the top content area.
+     *
+     * #### Notes
+     * Widgets must have a unique `id` property, which will be used as the DOM id.
+     */
+    private _addToTopArea;
+    /**
+     * Add a widget to the bottom content area.
+     *
+     * #### Notes
+     * Widgets must have a unique `id` property, which will be used as the DOM id.
+     */
+    private _addToBottomArea;
+    /**
+     * Handle a change to the layout.
+     */
+    private _onLayoutModified;
+    private _topHandler;
+    private _mainPanel;
+    private _bottomPanel;
+    private _layoutDebouncer;
+    private _layoutModified;
+}