@theia/notebook 1.41.0

package/src/browser/notebook-renderer-registry.ts

@@ -0,0 +1,62 @@
+// *****************************************************************************
+// Copyright (C) 2023 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, Path } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { NotebookRendererDescriptor } from '../common/notebook-protocol';
+
+export interface NotebookRendererInfo {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+    readonly entrypoint: { readonly extends?: string; readonly uri: string };
+    readonly requiresMessaging: boolean;
+}
+
+@injectable()
+export class NotebookRendererRegistry {
+
+    readonly notebookRenderers: NotebookRendererInfo[] = [];
+
+    registerNotebookRenderer(type: NotebookRendererDescriptor, basePath: string): Disposable {
+        let entrypoint;
+        if (typeof type.entrypoint === 'string') {
+            entrypoint = {
+                uri: new Path(basePath).join(type.entrypoint).toString()
+            };
+        } else {
+            entrypoint = {
+                uri: new Path(basePath).join(type.entrypoint.path).toString(),
+                extends: type.entrypoint.extends
+            };
+        }
+
+        this.notebookRenderers.push({
+            ...type,
+            mimeTypes: type.mimeTypes || [],
+            requiresMessaging: type.requiresMessaging === 'always' || type.requiresMessaging === 'optional',
+            entrypoint
+        });
+        return Disposable.create(() => {
+            this.notebookRenderers.splice(this.notebookRenderers.findIndex(renderer => renderer.id === type.id), 1);
+        });
+    }
+}
+

package/src/browser/notebook-type-registry.ts

@@ -0,0 +1,30 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { Disposable } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { NotebookTypeDescriptor } from '../common/notebook-protocol';
+
+@injectable()
+export class NotebookTypeRegistry {
+    readonly notebookTypes: NotebookTypeDescriptor[] = [];
+
+    registerNotebookType(type: NotebookTypeDescriptor): Disposable {
+        this.notebookTypes.push(type);
+        return Disposable.create(() => {
+            this.notebookTypes.splice(this.notebookTypes.indexOf(type), 1);
+        });
+    }
+}

package/src/browser/renderers/cell-output-webview.ts

@@ -0,0 +1,32 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { Disposable } from '@theia/core';
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+
+export const CellOutputWebviewFactory = Symbol('outputWebviewFactory');
+
+export type CellOutputWebviewFactory = (cell: NotebookCellModel) => Promise<CellOutputWebview>;
+
+export interface CellOutputWebview extends Disposable {
+
+    readonly id: string;
+
+    render(): React.JSX.Element;
+
+    attachWebview(): void;
+    isAttached(): boolean
+}

package/src/browser/service/notebook-cell-context-manager.ts

@@ -0,0 +1,70 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { ContextKeyService, ScopedValueStore } from '@theia/core/lib/browser/context-key-service';
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+import { NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_TYPE } from '../contributions/notebook-context-keys';
+import { Disposable, DisposableCollection, Emitter } from '@theia/core';
+import { CellKind } from '../../common';
+import { NotebookExecutionStateService } from '../service/notebook-execution-state-service';
+
+@injectable()
+export class NotebookCellContextManager implements Disposable {
+    @inject(ContextKeyService) protected contextKeyService: ContextKeyService;
+
+    @inject(NotebookExecutionStateService)
+    protected readonly executionStateService: NotebookExecutionStateService;
+
+    protected readonly toDispose = new DisposableCollection();
+
+    protected currentStore: ScopedValueStore;
+    protected currentContext: HTMLLIElement;
+
+    protected readonly onDidChangeContextEmitter = new Emitter<void>();
+    readonly onDidChangeContext = this.onDidChangeContextEmitter.event;
+
+    updateCellContext(cell: NotebookCellModel, newHtmlContext: HTMLLIElement): void {
+        if (newHtmlContext !== this.currentContext) {
+            this.toDispose.dispose();
+            this.currentStore?.dispose();
+
+            this.currentContext = newHtmlContext;
+            this.currentStore = this.contextKeyService.createScoped(newHtmlContext);
+
+            this.currentStore.setContext(NOTEBOOK_CELL_TYPE, cell.cellKind === CellKind.Code ? 'code' : 'markdown');
+
+            this.toDispose.push(cell.onDidRequestCellEditChange(cellEdit => {
+                this.currentStore?.setContext(NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, cellEdit);
+                this.onDidChangeContextEmitter.fire();
+            }));
+            this.toDispose.push(this.executionStateService.onDidChangeExecution(e => {
+                if (e.affectsCell(cell.uri)) {
+                    this.currentStore?.setContext(NOTEBOOK_CELL_EXECUTING, !!e.changed);
+                    this.currentStore?.setContext(NOTEBOOK_CELL_EXECUTION_STATE, e.changed?.state ?? 'idle');
+                    this.onDidChangeContextEmitter.fire();
+                }
+            }));
+            this.onDidChangeContextEmitter.fire();
+        }
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+        this.currentStore?.dispose();
+        this.onDidChangeContextEmitter.dispose();
+    }
+}

package/src/browser/service/notebook-editor-service.ts

@@ -0,0 +1,86 @@
+// *****************************************************************************
+// Copyright (C) 2023 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
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, DisposableCollection, Emitter } from '@theia/core';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { ApplicationShell } from '@theia/core/lib/browser';
+import { NotebookEditorWidget, NOTEBOOK_EDITOR_ID_PREFIX } from '../notebook-editor-widget';
+
+@injectable()
+export class NotebookEditorWidgetService implements Disposable {
+
+    @inject(ApplicationShell)
+    protected applicationShell: ApplicationShell;
+
+    private readonly notebookEditors = new Map<string, NotebookEditorWidget>();
+
+    private readonly onNotebookEditorAddEmitter = new Emitter<NotebookEditorWidget>();
+    private readonly onNotebookEditorsRemoveEmitter = new Emitter<NotebookEditorWidget>();
+    readonly onDidAddNotebookEditor = this.onNotebookEditorAddEmitter.event;
+    readonly onDidRemoveNotebookEditor = this.onNotebookEditorsRemoveEmitter.event;
+
+    private readonly onFocusedEditorChangedEmitter = new Emitter<NotebookEditorWidget>();
+    readonly onFocusedEditorChanged = this.onFocusedEditorChangedEmitter.event;
+
+    private readonly toDispose = new DisposableCollection();
+
+    currentFocusedEditor?: NotebookEditorWidget = undefined;
+
+    @postConstruct()
+    protected init(): void {
+        this.toDispose.push(this.applicationShell.onDidChangeActiveWidget(event => {
+            if (event.newValue?.id.startsWith(NOTEBOOK_EDITOR_ID_PREFIX) && event.newValue !== this.currentFocusedEditor) {
+                this.currentFocusedEditor = event.newValue as NotebookEditorWidget;
+                this.onFocusedEditorChangedEmitter.fire(this.currentFocusedEditor);
+            }
+        }));
+    }
+
+    dispose(): void {
+        this.onNotebookEditorAddEmitter.dispose();
+        this.onNotebookEditorsRemoveEmitter.dispose();
+        this.onFocusedEditorChangedEmitter.dispose();
+        this.toDispose.dispose();
+    }
+
+    // --- editor management
+
+    addNotebookEditor(editor: NotebookEditorWidget): void {
+        this.notebookEditors.set(editor.id, editor);
+        this.onNotebookEditorAddEmitter.fire(editor);
+    }
+
+    removeNotebookEditor(editor: NotebookEditorWidget): void {
+        if (this.notebookEditors.has(editor.id)) {
+            this.notebookEditors.delete(editor.id);
+            this.onNotebookEditorsRemoveEmitter.fire(editor);
+        }
+    }
+
+    getNotebookEditor(editorId: string): NotebookEditorWidget | undefined {
+        return this.notebookEditors.get(editorId);
+    }
+
+    listNotebookEditors(): readonly NotebookEditorWidget[] {
+        return [...this.notebookEditors].map(e => e[1]);
+    }
+
+}

package/src/browser/service/notebook-execution-service.ts

@@ -0,0 +1,139 @@
+// *****************************************************************************
+// Copyright (C) 2023 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { CellExecution, NotebookExecutionStateService } from '../service/notebook-execution-state-service';
+import { CellKind, NotebookCellExecutionState } from '../../common';
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+import { NotebookModel } from '../view-model/notebook-model';
+import { NotebookKernelService, NotebookKernel } from './notebook-kernel-service';
+import { CommandService, Disposable } from '@theia/core';
+import { NotebookKernelQuickPickService, NotebookKernelQuickPickServiceImpl } from './notebook-kernel-quick-pick-service';
+import { NotebookKernelHistoryService } from './notebook-kernel-history-service';
+import { NotebookCommands } from '../contributions/notebook-actions-contribution';
+
+export interface CellExecutionParticipant {
+    onWillExecuteCell(executions: CellExecution[]): Promise<void>;
+}
+
+@injectable()
+export class NotebookExecutionService {
+
+    @inject(NotebookExecutionStateService)
+    protected notebookExecutionStateService: NotebookExecutionStateService;
+
+    @inject(NotebookKernelService)
+    protected notebookKernelService: NotebookKernelService;
+
+    @inject(NotebookKernelHistoryService)
+    protected notebookKernelHistoryService: NotebookKernelHistoryService;
+
+    @inject(CommandService)
+    protected commandService: CommandService;
+
+    @inject(NotebookKernelQuickPickService)
+    protected notebookKernelQuickPickService: NotebookKernelQuickPickServiceImpl;
+
+    private readonly cellExecutionParticipants = new Set<CellExecutionParticipant>();
+
+    async executeNotebookCells(notebook: NotebookModel, cells: Iterable<NotebookCellModel>): Promise<void> {
+        const cellsArr = Array.from(cells)
+            .filter(c => c.cellKind === CellKind.Code);
+        if (!cellsArr.length) {
+            return;
+        }
+
+        // create cell executions
+        const cellExecutions: [NotebookCellModel, CellExecution][] = [];
+        for (const cell of cellsArr) {
+            const cellExe = this.notebookExecutionStateService.getCellExecution(cell.uri);
+            if (!cellExe) {
+                cellExecutions.push([cell, this.notebookExecutionStateService.createCellExecution(notebook.uri, cell.handle)]);
+            }
+        }
+
+        const kernel = await this.resolveKernel(notebook);
+
+        if (!kernel) {
+            // clear all pending cell executions
+            cellExecutions.forEach(cellExe => cellExe[1].complete({}));
+            return;
+        }
+
+        // filter cell executions based on selected kernel
+        const validCellExecutions: CellExecution[] = [];
+        for (const [cell, cellExecution] of cellExecutions) {
+            if (!kernel.supportedLanguages.includes(cell.language)) {
+                cellExecution.complete({});
+            } else {
+                validCellExecutions.push(cellExecution);
+            }
+        }
+
+        // request execution
+        if (validCellExecutions.length > 0) {
+            await this.runExecutionParticipants(validCellExecutions);
+
+            this.notebookKernelService.selectKernelForNotebook(kernel, notebook);
+            await kernel.executeNotebookCellsRequest(notebook.uri, validCellExecutions.map(c => c.cellHandle));
+            // the connecting state can change before the kernel resolves executeNotebookCellsRequest
+            const unconfirmed = validCellExecutions.filter(exe => exe.state === NotebookCellExecutionState.Unconfirmed);
+            if (unconfirmed.length) {
+                unconfirmed.forEach(exe => exe.complete({}));
+            }
+        }
+    }
+
+    registerExecutionParticipant(participant: CellExecutionParticipant): Disposable {
+        this.cellExecutionParticipants.add(participant);
+        return Disposable.create(() => this.cellExecutionParticipants.delete(participant));
+    }
+
+    private async runExecutionParticipants(executions: CellExecution[]): Promise<void> {
+        for (const participant of this.cellExecutionParticipants) {
+            await participant.onWillExecuteCell(executions);
+        }
+        return;
+    }
+
+    async cancelNotebookCellHandles(notebook: NotebookModel, cells: Iterable<number>): Promise<void> {
+        const cellsArr = Array.from(cells);
+        const kernel = this.notebookKernelService.getSelectedOrSuggestedKernel(notebook);
+        if (kernel) {
+            await kernel.cancelNotebookCellExecution(notebook.uri, cellsArr);
+        }
+    }
+
+    async cancelNotebookCells(notebook: NotebookModel, cells: Iterable<NotebookCellModel>): Promise<void> {
+        this.cancelNotebookCellHandles(notebook, Array.from(cells, cell => cell.handle));
+    }
+
+    async resolveKernel(notebook: NotebookModel): Promise<NotebookKernel | undefined> {
+        const alreadySelected = this.notebookKernelHistoryService.getKernels(notebook);
+
+        if (alreadySelected.selected) {
+            return alreadySelected.selected;
+        }
+
+        await this.commandService.executeCommand(NotebookCommands.SELECT_KERNEL_COMMAND.id, notebook);
+        const { selected } = this.notebookKernelHistoryService.getKernels(notebook);
+        return selected;
+    }
+}