@theia/notebook 1.48.2 → 1.49.0

package/src/browser/contributions/notebook-label-provider-contribution.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { codicon, LabelProvider, LabelProviderContribution } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { CellKind } from '../../common';
+import { NotebookService } from '../service/notebook-service';
+import { NotebookCellOutlineNode } from './notebook-outline-contribution';
+import type Token = require('markdown-it/lib/token');
+import markdownit = require('@theia/core/shared/markdown-it');
+
+@injectable()
+export class NotebookLabelProviderContribution implements LabelProviderContribution {
+
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    protected markdownIt = markdownit();
+
+    canHandle(element: object): number {
+        if (NotebookCellOutlineNode.is(element)) {
+            return 200;
+        }
+        return 0;
+    }
+
+    getIcon(element: NotebookCellOutlineNode): string {
+        return element.notebookCell.cellKind === CellKind.Markup ? codicon('markdown') : codicon('code');
+    }
+
+    getName(element: NotebookCellOutlineNode): string {
+        return element.notebookCell.cellKind === CellKind.Code ?
+            element.notebookCell.text.split('\n')[0] :
+            this.extractPlaintext(this.markdownIt.parse(element.notebookCell.text.split('\n')[0], {}));
+    }
+
+    getLongName(element: NotebookCellOutlineNode): string {
+        return element.notebookCell.cellKind === CellKind.Code ?
+            element.notebookCell.text.split('\n')[0] :
+            this.extractPlaintext(this.markdownIt.parse(element.notebookCell.text.split('\n')[0], {}));
+    }
+
+    extractPlaintext(parsedMarkdown: Token[]): string {
+        return parsedMarkdown.map(token => token.children ? this.extractPlaintext(token.children) : token.content).join('');
+    }
+
+}

package/src/browser/contributions/notebook-outline-contribution.ts

@@ -0,0 +1,112 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { codicon, FrontendApplicationContribution, LabelProvider, TreeNode } from '@theia/core/lib/browser';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { OutlineViewService } from '@theia/outline-view/lib/browser/outline-view-service';
+import { NotebookModel } from '../view-model/notebook-model';
+import { OutlineSymbolInformationNode } from '@theia/outline-view/lib/browser/outline-view-widget';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+import { DisposableCollection, URI } from '@theia/core';
+import { CellKind, CellUri } from '../../common';
+import { NotebookService } from '../service/notebook-service';
+export interface NotebookCellOutlineNode extends OutlineSymbolInformationNode {
+    notebookCell: NotebookCellModel;
+    uri: URI;
+}
+
+export namespace NotebookCellOutlineNode {
+    export function is(element: object): element is NotebookCellOutlineNode {
+        return TreeNode.is(element) && OutlineSymbolInformationNode.is(element) && 'notebookCell' in element;
+    }
+}
+
+@injectable()
+export class NotebookOutlineContribution implements FrontendApplicationContribution {
+
+    @inject(NotebookEditorWidgetService)
+    protected readonly notebookEditorWidgetService: NotebookEditorWidgetService;
+
+    @inject(OutlineViewService)
+    protected readonly outlineViewService: OutlineViewService;
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
+    protected currentEditor?: NotebookEditorWidget;
+
+    protected editorListeners: DisposableCollection = new DisposableCollection();
+    protected editorModelListeners: DisposableCollection = new DisposableCollection();
+
+    onStart(): void {
+        this.notebookEditorWidgetService.onDidChangeFocusedEditor(editor => this.updateOutline(editor));
+
+        this.outlineViewService.onDidSelect(node => this.selectCell(node));
+        this.outlineViewService.onDidTapNode(node => this.selectCell(node));
+    }
+
+    protected async updateOutline(editor: NotebookEditorWidget | undefined): Promise<void> {
+        if (editor && !editor.isDisposed) {
+            await editor.ready;
+            this.currentEditor = editor;
+            this.editorListeners.dispose();
+            this.editorListeners.push(editor.onDidChangeVisibility(() => {
+                if (this.currentEditor === editor && !editor.isVisible) {
+                    this.outlineViewService.publish([]);
+                }
+            }));
+            if (editor.model) {
+                this.editorModelListeners.dispose();
+                this.editorModelListeners.push(editor.model.onDidChangeSelectedCell(() => {
+                    if (editor === this.currentEditor) {
+                        this.updateOutline(editor);
+                    }
+                }));
+                const roots = editor && editor.model && await this.createRoots(editor.model);
+                this.outlineViewService.publish(roots || []);
+            }
+        }
+    }
+
+    protected async createRoots(model: NotebookModel): Promise<OutlineSymbolInformationNode[] | undefined> {
+        return model.cells.map(cell => ({
+            id: cell.uri.toString(),
+            iconClass: cell.cellKind === CellKind.Markup ? codicon('markdown') : codicon('code'),
+            parent: undefined,
+            children: [],
+            selected: model.selectedCell === cell,
+            expanded: false,
+            notebookCell: cell,
+            uri: model.uri,
+        } as NotebookCellOutlineNode));
+    }
+
+    selectCell(node: object): void {
+        if (NotebookCellOutlineNode.is(node)) {
+            const parsed = CellUri.parse(node.notebookCell.uri);
+            const model = parsed && this.notebookService.getNotebookEditorModel(parsed.notebook);
+            if (model) {
+                model.setSelectedCell(node.notebookCell);
+            }
+        }
+    }
+
+}

package/src/browser/contributions/notebook-output-action-contribution.ts

@@ -0,0 +1,82 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Command, CommandContribution, CommandRegistry } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { CellOutput, CellUri } from '../../common';
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+import { EditorManager } from '@theia/editor/lib/browser';
+
+export namespace NotebookOutputCommands {
+    export const ENABLE_SCROLLING = Command.toDefaultLocalizedCommand({
+        id: 'cellOutput.enableScrolling',
+    });
+
+    export const OPEN_LARGE_OUTPUT = Command.toDefaultLocalizedCommand({
+        id: 'workbench.action.openLargeOutput',
+        label: 'Open Large Output'
+    });
+}
+
+@injectable()
+export class NotebookOutputActionContribution implements CommandContribution {
+
+    @inject(NotebookEditorWidgetService)
+    protected readonly notebookEditorService: NotebookEditorWidgetService;
+
+    @inject(EditorManager)
+    protected readonly editorManager: EditorManager;
+
+    registerCommands(commands: CommandRegistry): void {
+        commands.registerCommand(NotebookOutputCommands.ENABLE_SCROLLING, {
+            execute: outputId => {
+                const [cell, output] = this.findOutputAndCell(outputId) ?? [];
+                if (cell && output?.metadata) {
+                    output.metadata['scrollable'] = true;
+                    cell.restartOutputRenderer(output.outputId);
+                }
+            }
+        });
+
+        commands.registerCommand(NotebookOutputCommands.OPEN_LARGE_OUTPUT, {
+            execute: outputId => {
+                const [cell, output] = this.findOutputAndCell(outputId) ?? [];
+                if (cell && output) {
+                    this.editorManager.open(CellUri.generateCellOutputUri(CellUri.parse(cell.uri)!.notebook, output.outputId));
+                }
+            }
+        });
+    }
+
+    protected findOutputAndCell(output: string): [NotebookCellModel, CellOutput] | undefined {
+        const model = this.notebookEditorService.focusedEditor?.model;
+        if (!model) {
+            return undefined;
+        }
+
+        const outputId = output.slice(0, output.lastIndexOf('-'));
+
+        for (const cell of model.cells) {
+            for (const outputModel of cell.outputs) {
+                if (outputModel.outputId === outputId) {
+                    return [cell, outputModel];
+                }
+            }
+        }
+    }
+
+}

package/src/browser/contributions/notebook-preferences.ts

@@ -0,0 +1,31 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core';
+import { PreferenceSchema } from '@theia/core/lib/browser';
+
+export const NOTEBOOK_LINE_NUMBERS = 'notebook.lineNumbers';
+
+export const notebookPreferenceSchema: PreferenceSchema = {
+    properties: {
+        [NOTEBOOK_LINE_NUMBERS]: {
+            type: 'string',
+            enum: ['on', 'off'],
+            default: 'off',
+            description: nls.localizeByDefault('Controls the display of line numbers in the cell editor.')
+        },
+    }
+};

package/src/browser/notebook-cell-resource-resolver.ts

@@ -65,7 +65,7 @@ export class NotebookCellResourceResolver implements ResourceResolver {
     protected readonly notebookService: NotebookService;
 
     async resolve(uri: URI): Promise<Resource> {
-        if (uri.scheme !== CellUri.scheme) {
+        if (uri.scheme !== CellUri.cellUriScheme) {
             throw new Error(`Cannot resolve cell uri with scheme '${uri.scheme}'`);
         }
 
@@ -90,3 +90,41 @@ export class NotebookCellResourceResolver implements ResourceResolver {
     }
 
 }
+
+@injectable()
+export class NotebookOutputResourceResolver implements ResourceResolver {
+
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
+    async resolve(uri: URI): Promise<Resource> {
+        if (uri.scheme !== CellUri.outputUriScheme) {
+            throw new Error(`Cannot resolve output uri with scheme '${uri.scheme}'`);
+        }
+
+        const parsedUri = CellUri.parseCellOutputUri(uri);
+        if (!parsedUri) {
+            throw new Error(`Cannot parse uri '${uri.toString()}'`);
+        }
+
+        const notebookModel = this.notebookService.getNotebookEditorModel(parsedUri.notebook);
+
+        if (!notebookModel) {
+            throw new Error(`No notebook found for uri '${parsedUri.notebook}'`);
+        }
+
+        const ouputModel = notebookModel.cells.flatMap(cell => cell.outputs).find(output => output.outputId === parsedUri.outputId);
+
+        if (!ouputModel) {
+            throw new Error(`No output found with id '${parsedUri.outputId}' in '${parsedUri.notebook}'`);
+        }
+
+        return {
+            uri: uri,
+            dispose: () => { },
+            readContents: async () => ouputModel.outputs[0].data.toString(),
+            readOnly: true,
+        };
+    }
+
+}

package/src/browser/notebook-editor-widget-factory.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { URI } from '@theia/core';
+import { nls, URI } from '@theia/core';
 import { WidgetFactory, NavigatableWidgetOptions, LabelProvider } from '@theia/core/lib/browser';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { NotebookEditorWidget, NotebookEditorWidgetContainerFactory, NotebookEditorProps } from './notebook-editor-widget';
@@ -51,10 +51,13 @@ export class NotebookEditorWidgetFactory implements WidgetFactory {
 
         const editor = await this.createEditor(uri, options.notebookType);
 
-        const icon = this.labelProvider.getIcon(uri);
-        editor.title.label = this.labelProvider.getName(uri);
-        editor.title.iconClass = icon + ' file-icon';
-
+        this.setLabels(editor, uri);
+        const labelListener = this.labelProvider.onDidChange(event => {
+            if (event.affects(uri)) {
+                this.setLabels(editor, uri);
+            }
+        });
+        editor.onDidDispose(() => labelListener.dispose());
         return editor;
     }
 
@@ -67,4 +70,14 @@ export class NotebookEditorWidgetFactory implements WidgetFactory {
         });
     }
 
+    private setLabels(editor: NotebookEditorWidget, uri: URI): void {
+        editor.title.caption = uri.path.fsPath();
+        if (editor.model?.readOnly) {
+            editor.title.caption += ` • ${nls.localizeByDefault('Read-only')}`;
+        }
+        const icon = this.labelProvider.getIcon(uri);
+        editor.title.label = this.labelProvider.getName(uri);
+        editor.title.iconClass = icon + ' file-icon';
+    }
+
 }

package/src/browser/notebook-editor-widget.tsx

@@ -16,7 +16,7 @@
 
 import * as React from '@theia/core/shared/react';
 import { CommandRegistry, MenuModelRegistry, URI } from '@theia/core';
-import { ReactWidget, Navigatable, SaveableSource, Message, DelegatingSaveable, lock, unlock } from '@theia/core/lib/browser';
+import { ReactWidget, Navigatable, SaveableSource, Message, DelegatingSaveable, lock, unlock, animationFrame } from '@theia/core/lib/browser';
 import { ReactNode } from '@theia/core/shared/react';
 import { CellKind } from '../common';
 import { CellRenderer as CellRenderer, NotebookCellListView } from './view/notebook-cell-list-view';
@@ -32,6 +32,7 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import { NotebookContextManager } from './service/notebook-context-manager';
 import { NotebookViewportService } from './view/notebook-viewport-service';
+import { NotebookCellCommands } from './contributions/notebook-cell-actions-contribution';
 const PerfectScrollbar = require('react-perfect-scrollbar');
 
 export const NotebookEditorWidgetContainerFactory = Symbol('NotebookEditorWidgetContainerFactory');
@@ -43,6 +44,7 @@ export function createNotebookEditorWidgetContainer(parent: interfaces.Container
 
     child.bind(NotebookContextManager).toSelf().inSingletonScope();
     child.bind(NotebookMainToolbarRenderer).toSelf().inSingletonScope();
+    child.bind(NotebookCellToolbarFactory).toSelf().inSingletonScope();
     child.bind(NotebookCodeCellRenderer).toSelf().inSingletonScope();
     child.bind(NotebookMarkdownCellRenderer).toSelf().inSingletonScope();
     child.bind(NotebookViewportService).toSelf().inSingletonScope();
@@ -116,11 +118,12 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     readonly onPostRendererMessage = this.onPostRendererMessageEmitter.event;
 
     protected readonly onDidReceiveKernelMessageEmitter = new Emitter<unknown>();
-    readonly onDidRecieveKernelMessage = this.onDidReceiveKernelMessageEmitter.event;
+    readonly onDidReceiveKernelMessage = this.onDidReceiveKernelMessageEmitter.event;
 
     protected readonly renderers = new Map<CellKind, CellRenderer>();
     protected _model?: NotebookModel;
     protected _ready: Deferred<NotebookModel> = new Deferred();
+    protected scrollBarRef = React.createRef<{ updateScroll(): void }>();
 
     get notebookType(): string {
         return this.props.notebookType;
@@ -152,12 +155,25 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         this.renderers.set(CellKind.Markup, this.markdownCellRenderer);
         this.renderers.set(CellKind.Code, this.codeCellRenderer);
         this._ready.resolve(this.waitForData());
+        this.ready.then(model => {
+            if (model.cells.length === 1 && model.cells[0].source === '') {
+                this.commandRegistry.executeCommand(NotebookCellCommands.EDIT_COMMAND.id, model, model.cells[0]);
+                model.setSelectedCell(model.cells[0]);
+            }
+            model.cells.forEach(cell => cell.onWillBlurCellEditor(() => this.node.focus()));
+            model.onDidAddOrRemoveCell(e => e.newCellIds?.forEach(cellId => model.cells.find(cell => cell.handle === cellId)?.onWillBlurCellEditor(() => this.node.focus())));
+        });
     }
 
     protected async waitForData(): Promise<NotebookModel> {
         this._model = await this.props.notebookData;
         this.saveable.delegate = this._model;
         this.toDispose.push(this._model);
+        this.toDispose.push(this._model.onDidChangeContent(() => {
+            // Update the scroll bar content after the content has changed
+            // Wait one frame to ensure that the content has been rendered
+            animationFrame().then(() => this.scrollBarRef.current?.updateScroll());
+        }));
         this.toDispose.push(this._model.onDidChangeReadOnly(readOnly => {
             if (readOnly) {
                 lock(this.title);
@@ -204,6 +220,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
                 {this.notebookMainToolbarRenderer.render(this._model, this.node)}
                 <div className='theia-notebook-viewport' ref={(ref: HTMLDivElement) => this.viewportService.viewportElement = ref}>
                     <PerfectScrollbar className='theia-notebook-scroll-container'
+                        ref={this.scrollBarRef}
                         onScrollY={(e: HTMLDivElement) => this.viewportService.onScroll(e)}>
                         <NotebookCellListView renderers={this.renderers}
                             notebookModel={this._model}
@@ -241,6 +258,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         this.onDidReceiveKernelMessageEmitter.dispose();
         this.onPostRendererMessageEmitter.dispose();
         this.viewportService.dispose();
+        this._model?.dispose();
         super.dispose();
     }
 

package/src/browser/notebook-frontend-module.ts

@@ -16,7 +16,7 @@
 import '../../src/browser/style/index.css';
 
 import { ContainerModule } from '@theia/core/shared/inversify';
-import { KeybindingContribution, OpenHandler, WidgetFactory } from '@theia/core/lib/browser';
+import { FrontendApplicationContribution, KeybindingContribution, LabelProviderContribution, OpenHandler, PreferenceContribution, WidgetFactory } from '@theia/core/lib/browser';
 import { ColorContribution } from '@theia/core/lib/browser/color-application-contribution';
 import { NotebookOpenHandler } from './notebook-open-handler';
 import { CommandContribution, MenuContribution, ResourceResolver, } from '@theia/core';
@@ -24,10 +24,9 @@ import { NotebookTypeRegistry } from './notebook-type-registry';
 import { NotebookRendererRegistry } from './notebook-renderer-registry';
 import { NotebookService } from './service/notebook-service';
 import { NotebookEditorWidgetFactory } from './notebook-editor-widget-factory';
-import { NotebookCellResourceResolver } from './notebook-cell-resource-resolver';
+import { NotebookCellResourceResolver, NotebookOutputResourceResolver } from './notebook-cell-resource-resolver';
 import { NotebookModelResolverService } from './service/notebook-model-resolver-service';
 import { NotebookCellActionContribution } from './contributions/notebook-cell-actions-contribution';
-import { NotebookCellToolbarFactory } from './view/notebook-cell-toolbar-factory';
 import { createNotebookModelContainer, NotebookModel, NotebookModelFactory, NotebookModelProps } from './view-model/notebook-model';
 import { createNotebookCellModelContainer, NotebookCellModel, NotebookCellModelFactory, NotebookCellModelProps } from './view-model/notebook-cell-model';
 import { createNotebookEditorWidgetContainer, NotebookEditorWidgetContainerFactory, NotebookEditorProps, NotebookEditorWidget } from './notebook-editor-widget';
@@ -41,6 +40,11 @@ import { NotebookEditorWidgetService } from './service/notebook-editor-widget-se
 import { NotebookRendererMessagingService } from './service/notebook-renderer-messaging-service';
 import { NotebookColorContribution } from './contributions/notebook-color-contribution';
 import { NotebookMonacoTextModelService } from './service/notebook-monaco-text-model-service';
+import { NotebookOutlineContribution } from './contributions/notebook-outline-contribution';
+import { NotebookLabelProviderContribution } from './contributions/notebook-label-provider-contribution';
+import { NotebookOutputActionContribution } from './contributions/notebook-output-action-contribution';
+import { NotebookClipboardService } from './service/notebook-clipboard-service';
+import { notebookPreferenceSchema } from './contributions/notebook-preferences';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookColorContribution).toSelf().inSingletonScope();
@@ -53,7 +57,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookRendererRegistry).toSelf().inSingletonScope();
 
     bind(WidgetFactory).to(NotebookEditorWidgetFactory).inSingletonScope();
-    bind(NotebookCellToolbarFactory).toSelf().inSingletonScope();
 
     bind(NotebookService).toSelf().inSingletonScope();
     bind(NotebookEditorWidgetService).toSelf().inSingletonScope();
@@ -63,10 +66,13 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookRendererMessagingService).toSelf().inSingletonScope();
     bind(NotebookKernelHistoryService).toSelf().inSingletonScope();
     bind(NotebookKernelQuickPickService).toSelf().inSingletonScope();
+    bind(NotebookClipboardService).toSelf().inSingletonScope();
 
     bind(NotebookCellResourceResolver).toSelf().inSingletonScope();
     bind(ResourceResolver).toService(NotebookCellResourceResolver);
     bind(NotebookModelResolverService).toSelf().inSingletonScope();
+    bind(NotebookOutputResourceResolver).toSelf().inSingletonScope();
+    bind(ResourceResolver).toService(NotebookOutputResourceResolver);
 
     bind(NotebookCellActionContribution).toSelf().inSingletonScope();
     bind(MenuContribution).toService(NotebookCellActionContribution);
@@ -78,6 +84,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MenuContribution).toService(NotebookActionsContribution);
     bind(KeybindingContribution).toService(NotebookActionsContribution);
 
+    bind(NotebookOutputActionContribution).toSelf().inSingletonScope();
+    bind(CommandContribution).toService(NotebookOutputActionContribution);
+
     bind(NotebookEditorWidgetContainerFactory).toFactory(ctx => (props: NotebookEditorProps) =>
         createNotebookEditorWidgetContainer(ctx.container, props).get(NotebookEditorWidget)
     );
@@ -89,4 +98,11 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     );
 
     bind(NotebookMonacoTextModelService).toSelf().inSingletonScope();
+
+    bind(NotebookOutlineContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(NotebookOutlineContribution);
+    bind(NotebookLabelProviderContribution).toSelf().inSingletonScope();
+    bind(LabelProviderContribution).toService(NotebookLabelProviderContribution);
+
+    bind(PreferenceContribution).toConstantValue({ schema: notebookPreferenceSchema });
 });

package/src/browser/notebook-open-handler.ts

@@ -14,32 +14,56 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { URI, MaybePromise } from '@theia/core';
+import { URI, MaybePromise, Disposable } from '@theia/core';
 import { NavigatableWidgetOpenHandler, WidgetOpenerOptions } from '@theia/core/lib/browser';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { injectable } from '@theia/core/shared/inversify';
 import { NotebookFileSelector, NotebookTypeDescriptor } from '../common/notebook-protocol';
-import { NotebookTypeRegistry } from './notebook-type-registry';
 import { NotebookEditorWidget } from './notebook-editor-widget';
 import { match } from '@theia/core/lib/common/glob';
 import { NotebookEditorWidgetOptions } from './notebook-editor-widget-factory';
 
+export interface NotebookWidgetOpenerOptions extends WidgetOpenerOptions {
+    notebookType?: string;
+}
+
 @injectable()
 export class NotebookOpenHandler extends NavigatableWidgetOpenHandler<NotebookEditorWidget> {
 
-    id: string = 'notebook';
+    readonly id = NotebookEditorWidget.ID;
+
+    protected notebookTypes: NotebookTypeDescriptor[] = [];
 
-    @inject(NotebookTypeRegistry)
-    protected notebookTypeRegistry: NotebookTypeRegistry;
+    registerNotebookType(notebookType: NotebookTypeDescriptor): Disposable {
+        this.notebookTypes.push(notebookType);
+        return Disposable.create(() => {
+            this.notebookTypes.splice(this.notebookTypes.indexOf(notebookType), 1);
+        });
+    }
+
+    canHandle(uri: URI, options?: NotebookWidgetOpenerOptions): MaybePromise<number> {
+        if (options?.notebookType) {
+            return this.canHandleType(uri, this.notebookTypes.find(type => type.type === options.notebookType));
+        }
+        return Math.max(...this.notebookTypes.map(type => this.canHandleType(uri, type)));
+    }
+
+    canHandleType(uri: URI, notebookType?: NotebookTypeDescriptor): number {
+        if (notebookType?.selector && this.matches(notebookType.selector, uri)) {
+            return this.calculatePriority(notebookType);
+        } else {
+            return 0;
+        }
+    }
 
-    canHandle(uri: URI, options?: WidgetOpenerOptions | undefined): MaybePromise<number> {
-        const priorities = this.notebookTypeRegistry.notebookTypes
-            .filter(notebook => notebook.selector && this.matches(notebook.selector, uri))
-            .map(notebook => this.calculatePriority(notebook));
-        return Math.max(...priorities);
+    protected calculatePriority(notebookType: NotebookTypeDescriptor | undefined): number {
+        if (!notebookType) {
+            return 0;
+        }
+        return notebookType.priority === 'option' ? 100 : 200;
     }
 
     protected findHighestPriorityType(uri: URI): NotebookTypeDescriptor | undefined {
-        const matchingTypes = this.notebookTypeRegistry.notebookTypes
+        const matchingTypes = this.notebookTypes
             .filter(notebookType => notebookType.selector && this.matches(notebookType.selector, uri))
             .map(notebookType => ({ descriptor: notebookType, priority: this.calculatePriority(notebookType) }));
 
@@ -56,15 +80,19 @@ export class NotebookOpenHandler extends NavigatableWidgetOpenHandler<NotebookEd
         return type.descriptor;
     }
 
-    protected calculatePriority(notebookType: NotebookTypeDescriptor | undefined): number {
-        if (!notebookType) {
-            return 0;
-        }
-        return notebookType.priority === 'option' ? 100 : 200;
+    // Override for better options typing
+    override open(uri: URI, options?: NotebookWidgetOpenerOptions): Promise<NotebookEditorWidget> {
+        return super.open(uri, options);
     }
 
-    protected override createWidgetOptions(uri: URI, options?: WidgetOpenerOptions | undefined): NotebookEditorWidgetOptions {
+    protected override createWidgetOptions(uri: URI, options?: NotebookWidgetOpenerOptions): NotebookEditorWidgetOptions {
         const widgetOptions = super.createWidgetOptions(uri, options);
+        if (options?.notebookType) {
+            return {
+                notebookType: options.notebookType,
+                ...widgetOptions
+            };
+        }
         const notebookType = this.findHighestPriorityType(uri);
         if (!notebookType) {
             throw new Error('No notebook types registered for uri: ' + uri.toString());
@@ -75,11 +103,11 @@ export class NotebookOpenHandler extends NavigatableWidgetOpenHandler<NotebookEd
         };
     }
 
-    matches(selectors: readonly NotebookFileSelector[], resource: URI): boolean {
+    protected matches(selectors: readonly NotebookFileSelector[], resource: URI): boolean {
         return selectors.some(selector => this.selectorMatches(selector, resource));
     }
 
-    selectorMatches(selector: NotebookFileSelector, resource: URI): boolean {
+    protected selectorMatches(selector: NotebookFileSelector, resource: URI): boolean {
         return !!selector.filenamePattern
             && match(selector.filenamePattern, resource.path.name + resource.path.ext);
     }