@theia/notebook 1.41.0

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

@@ -0,0 +1,357 @@
+// *****************************************************************************
+// 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 { Command, CommandRegistry, Disposable, Emitter, Event, URI } from '@theia/core';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { StorageService } from '@theia/core/lib/browser';
+import { NotebookKernelSourceAction } from '../../common';
+import { NotebookModel } from '../view-model/notebook-model';
+import { NotebookService } from './notebook-service';
+
+export interface SelectedNotebookKernelChangeEvent {
+    notebook: URI;
+    oldKernel: string | undefined;
+    newKernel: string | undefined;
+}
+
+export interface NotebookKernelMatchResult {
+    readonly selected: NotebookKernel | undefined;
+    readonly suggestions: NotebookKernel[];
+    readonly all: NotebookKernel[];
+    readonly hidden: NotebookKernel[];
+}
+
+export interface NotebookKernelChangeEvent {
+    label?: true;
+    description?: true;
+    detail?: true;
+    supportedLanguages?: true;
+    hasExecutionOrder?: true;
+    hasInterruptHandler?: true;
+}
+
+export interface NotebookKernel {
+    readonly id: string;
+    readonly viewType: string;
+    readonly onDidChange: Event<Readonly<NotebookKernelChangeEvent>>;
+    readonly extension: string;
+
+    readonly localResourceRoot: URI;
+    readonly preloadUris: URI[];
+    readonly preloadProvides: string[];
+
+    label: string;
+    description?: string;
+    detail?: string;
+    supportedLanguages: string[];
+    implementsInterrupt?: boolean;
+    implementsExecutionOrder?: boolean;
+
+    executeNotebookCellsRequest(uri: URI, cellHandles: number[]): Promise<void>;
+    cancelNotebookCellExecution(uri: URI, cellHandles: number[]): Promise<void>;
+}
+
+export const enum ProxyKernelState {
+    Disconnected = 1,
+    Connected = 2,
+    Initializing = 3
+}
+
+export interface INotebookProxyKernelChangeEvent extends NotebookKernelChangeEvent {
+    connectionState?: true;
+}
+
+export interface NotebookKernelDetectionTask {
+    readonly notebookType: string;
+}
+
+export interface NotebookTextModelLike { uri: URI; viewType: string }
+
+class KernelInfo {
+
+    private static logicClock = 0;
+
+    readonly kernel: NotebookKernel;
+    public score: number;
+    readonly time: number;
+
+    constructor(kernel: NotebookKernel) {
+        this.kernel = kernel;
+        this.score = -1;
+        this.time = KernelInfo.logicClock++;
+    }
+}
+
+export interface NotebookSourceActionChangeEvent {
+    notebook?: URI;
+    viewType: string;
+}
+
+export interface KernelSourceActionProvider {
+    readonly viewType: string;
+    onDidChangeSourceActions?: Event<void>;
+    provideKernelSourceActions(): Promise<NotebookKernelSourceAction[]>;
+}
+
+export class SourceCommand implements Disposable {
+    execution: Promise<void> | undefined;
+    protected readonly onDidChangeStateEmitter = new Emitter<void>();
+    readonly onDidChangeState = this.onDidChangeStateEmitter.event;
+
+    constructor(
+        readonly commandRegistry: CommandRegistry,
+        readonly command: Command,
+        readonly model: NotebookTextModelLike,
+        readonly isPrimary: boolean
+    ) { }
+
+    async run(): Promise<void> {
+        if (this.execution) {
+            return this.execution;
+        }
+
+        this.execution = this.runCommand();
+        this.onDidChangeStateEmitter.fire();
+        await this.execution;
+        this.execution = undefined;
+        this.onDidChangeStateEmitter.fire();
+    }
+
+    private async runCommand(): Promise<void> {
+        try {
+            await this.commandRegistry.executeCommand(this.command.id, {
+                uri: this.model.uri,
+            });
+
+        } catch (error) {
+            console.warn(`Kernel source command failed: ${error}`);
+        }
+    }
+
+    dispose(): void {
+        this.onDidChangeStateEmitter.dispose();
+    }
+
+}
+
+const NOTEBOOK_KERNEL_BINDING_STORAGE_KEY = 'notebook.kernel.bindings';
+@injectable()
+export class NotebookKernelService implements Disposable {
+
+    @inject(NotebookService)
+    protected notebookService: NotebookService;
+
+    @inject(StorageService)
+    protected storageService: StorageService;
+
+    private readonly kernels = new Map<string, KernelInfo>();
+
+    private notebookBindings: { [key: string]: string } = {};
+
+    private readonly kernelDetectionTasks = new Map<string, NotebookKernelDetectionTask[]>();
+    private readonly onDidChangeKernelDetectionTasksEmitter = new Emitter<string>();
+    readonly onDidChangeKernelDetectionTasks = this.onDidChangeKernelDetectionTasksEmitter.event;
+
+    private readonly onDidChangeSourceActionsEmitter = new Emitter<NotebookSourceActionChangeEvent>();
+    private readonly kernelSourceActionProviders = new Map<string, KernelSourceActionProvider[]>();
+    readonly onDidChangeSourceActions: Event<NotebookSourceActionChangeEvent> = this.onDidChangeSourceActionsEmitter.event;
+
+    private readonly onDidAddKernelEmitter = new Emitter<NotebookKernel>();
+    readonly onDidAddKernel: Event<NotebookKernel> = this.onDidAddKernelEmitter.event;
+
+    private readonly onDidRemoveKernelEmitter = new Emitter<NotebookKernel>();
+    readonly onDidRemoveKernel: Event<NotebookKernel> = this.onDidRemoveKernelEmitter.event;
+
+    private readonly onDidChangeSelectedNotebookKernelBindingEmitter = new Emitter<SelectedNotebookKernelChangeEvent>();
+    readonly onDidChangeSelectedKernel: Event<SelectedNotebookKernelChangeEvent> = this.onDidChangeSelectedNotebookKernelBindingEmitter.event;
+
+    private readonly onDidChangeNotebookAffinityEmitter = new Emitter<void>();
+    readonly onDidChangeNotebookAffinity: Event<void> = this.onDidChangeNotebookAffinityEmitter.event;
+
+    @postConstruct()
+    init(): void {
+        this.storageService.getData(NOTEBOOK_KERNEL_BINDING_STORAGE_KEY).then((value: { [key: string]: string } | undefined) => {
+            if (value) {
+                this.notebookBindings = value;
+            }
+        });
+    }
+
+    registerKernel(kernel: NotebookKernel): Disposable {
+        if (this.kernels.has(kernel.id)) {
+            throw new Error(`NOTEBOOK CONTROLLER with id '${kernel.id}' already exists`);
+        }
+
+        this.kernels.set(kernel.id, new KernelInfo(kernel));
+        this.onDidAddKernelEmitter.fire(kernel);
+
+        // auto associate the new kernel to existing notebooks it was
+        // associated to in the past.
+        for (const notebook of this.notebookService.getNotebookModels()) {
+            this.tryAutoBindNotebook(notebook, kernel);
+        }
+
+        return Disposable.create(() => {
+            if (this.kernels.delete(kernel.id)) {
+                this.onDidRemoveKernelEmitter.fire(kernel);
+            }
+        });
+    }
+
+    getMatchingKernel(notebook: NotebookTextModelLike): NotebookKernelMatchResult {
+        const kernels: { kernel: NotebookKernel; instanceAffinity: number; score: number }[] = [];
+        for (const info of this.kernels.values()) {
+            const score = NotebookKernelService.score(info.kernel, notebook);
+            if (score) {
+                kernels.push({
+                    score,
+                    kernel: info.kernel,
+                    instanceAffinity: 1 /* vscode.NotebookControllerPriority.Default */,
+                });
+            }
+        }
+
+        kernels
+            .sort((a, b) => b.instanceAffinity - a.instanceAffinity || a.score - b.score || a.kernel.label.localeCompare(b.kernel.label));
+        const all = kernels.map(obj => obj.kernel);
+
+        // bound kernel
+        const selectedId = this.notebookBindings[`${notebook.viewType}/${notebook.uri}`];
+        const selected = selectedId ? this.kernels.get(selectedId)?.kernel : undefined;
+        const suggestions = kernels.filter(item => item.instanceAffinity > 1).map(item => item.kernel); // TODO implement notebookAffinity
+        const hidden = kernels.filter(item => item.instanceAffinity < 0).map(item => item.kernel);
+        return { all, selected, suggestions, hidden };
+
+    }
+
+    selectKernelForNotebook(kernel: NotebookKernel | undefined, notebook: NotebookTextModelLike): void {
+        const key = `${notebook.viewType}/${notebook.uri}`;
+        const oldKernel = this.notebookBindings[key];
+        if (oldKernel !== kernel?.id) {
+            if (kernel) {
+                this.notebookBindings[key] = kernel.id;
+            } else {
+                delete this.notebookBindings[key];
+            }
+            this.storageService.setData(NOTEBOOK_KERNEL_BINDING_STORAGE_KEY, this.notebookBindings);
+            this.onDidChangeSelectedNotebookKernelBindingEmitter.fire({ notebook: notebook.uri, oldKernel, newKernel: kernel?.id });
+        }
+    }
+
+    getSelectedOrSuggestedKernel(notebook: NotebookModel): NotebookKernel | undefined {
+        const info = this.getMatchingKernel(notebook);
+        if (info.selected) {
+            return info.selected;
+        }
+
+        return info.all.length === 1 ? info.all[0] : undefined;
+    }
+
+    getKernel(id: string): NotebookKernel | undefined {
+        return this.kernels.get(id)?.kernel;
+    }
+
+    private static score(kernel: NotebookKernel, notebook: NotebookTextModelLike): number {
+        if (kernel.viewType === '*') {
+            return 5;
+        } else if (kernel.viewType === notebook.viewType) {
+            return 10;
+        } else {
+            return 0;
+        }
+    }
+
+    private tryAutoBindNotebook(notebook: NotebookModel, onlyThisKernel?: NotebookKernel): void {
+
+        const id = this.notebookBindings[`${notebook.viewType}/${notebook.uri}`];
+        if (!id) {
+            // no kernel associated
+            return;
+        }
+        const existingKernel = this.kernels.get(id);
+        if (!existingKernel || !NotebookKernelService.score(existingKernel.kernel, notebook)) {
+            // associated kernel not known, not matching
+            return;
+        }
+        if (!onlyThisKernel || existingKernel.kernel === onlyThisKernel) {
+            this.onDidChangeSelectedNotebookKernelBindingEmitter.fire({ notebook: notebook.uri, oldKernel: undefined, newKernel: existingKernel.kernel.id });
+        }
+    }
+
+    registerNotebookKernelDetectionTask(task: NotebookKernelDetectionTask): Disposable {
+        const notebookType = task.notebookType;
+        const all = this.kernelDetectionTasks.get(notebookType) ?? [];
+        all.push(task);
+        this.kernelDetectionTasks.set(notebookType, all);
+        this.onDidChangeKernelDetectionTasksEmitter.fire(notebookType);
+        return Disposable.create(() => {
+            const allTasks = this.kernelDetectionTasks.get(notebookType) ?? [];
+            const taskIndex = allTasks.indexOf(task);
+            if (taskIndex >= 0) {
+                allTasks.splice(taskIndex, 1);
+                this.kernelDetectionTasks.set(notebookType, allTasks);
+                this.onDidChangeKernelDetectionTasksEmitter.fire(notebookType);
+            }
+        });
+    }
+
+    getKernelDetectionTasks(notebook: NotebookTextModelLike): NotebookKernelDetectionTask[] {
+        return this.kernelDetectionTasks.get(notebook.viewType) ?? [];
+    }
+
+    registerKernelSourceActionProvider(viewType: string, provider: KernelSourceActionProvider): Disposable {
+        const providers = this.kernelSourceActionProviders.get(viewType) ?? [];
+        providers.push(provider);
+        this.kernelSourceActionProviders.set(viewType, providers);
+        this.onDidChangeSourceActionsEmitter.fire({ viewType: viewType });
+
+        const eventEmitterDisposable = provider.onDidChangeSourceActions?.(() => {
+            this.onDidChangeSourceActionsEmitter.fire({ viewType: viewType });
+        });
+
+        return Disposable.create(() => {
+            const sourceProviders = this.kernelSourceActionProviders.get(viewType) ?? [];
+            const providerIndex = sourceProviders.indexOf(provider);
+            if (providerIndex >= 0) {
+                sourceProviders.splice(providerIndex, 1);
+                this.kernelSourceActionProviders.set(viewType, sourceProviders);
+            }
+
+            eventEmitterDisposable?.dispose();
+        });
+    }
+
+    async getKernelSourceActionsFromProviders(notebook: NotebookTextModelLike): Promise<NotebookKernelSourceAction[]> {
+        const viewType = notebook.viewType;
+        const providers = this.kernelSourceActionProviders.get(viewType) ?? [];
+        const promises = providers.map(provider => provider.provideKernelSourceActions());
+        const allActions = await Promise.all(promises);
+        return allActions.flat();
+    }
+
+    dispose(): void {
+        this.onDidChangeKernelDetectionTasksEmitter.dispose();
+        this.onDidChangeSourceActionsEmitter.dispose();
+        this.onDidAddKernelEmitter.dispose();
+        this.onDidRemoveKernelEmitter.dispose();
+        this.onDidChangeSelectedNotebookKernelBindingEmitter.dispose();
+        this.onDidChangeNotebookAffinityEmitter.dispose();
+    }
+}

package/src/browser/service/notebook-model-resolver-service.ts

@@ -0,0 +1,141 @@
+// *****************************************************************************
+// 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 { Emitter, URI } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { UriComponents } from '@theia/core/lib/common/uri';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { CellKind, NotebookData } from '../../common';
+import { NotebookModel } from '../view-model/notebook-model';
+import { NotebookService } from './notebook-service';
+import { NotebookTypeRegistry } from '../notebook-type-registry';
+import { NotebookFileSelector } from '../../common/notebook-protocol';
+
+export interface UntitledResource {
+    untitledResource: URI | undefined
+}
+@injectable()
+export class NotebookModelResolverService {
+
+    @inject(FileService)
+    protected fileService: FileService;
+
+    @inject(NotebookService)
+    protected notebookService: NotebookService;
+
+    @inject(NotebookTypeRegistry)
+    protected notebookTypeRegistry: NotebookTypeRegistry;
+
+    protected onDidChangeDirtyEmitter = new Emitter<NotebookModel>();
+    readonly onDidChangeDirty = this.onDidChangeDirtyEmitter.event;
+    protected onDidSaveNotebookEmitter = new Emitter<UriComponents>();
+    readonly onDidSaveNotebook = this.onDidSaveNotebookEmitter.event;
+
+    async resolve(resource: URI, viewType?: string): Promise<NotebookModel>;
+    async resolve(resource: UntitledResource, viewType: string): Promise<NotebookModel>;
+    async resolve(arg: URI | UntitledResource, viewType: string): Promise<NotebookModel> {
+        let resource: URI;
+        // let hasAssociatedFilePath = false;
+        if (arg instanceof URI) {
+            resource = arg;
+        } else {
+            arg = arg as UntitledResource;
+            if (!arg.untitledResource) {
+                const notebookTypeInfo = this.notebookTypeRegistry.notebookTypes.find(info => info.type === viewType);
+                if (!notebookTypeInfo) {
+                    throw new Error('UNKNOWN view type: ' + viewType);
+                }
+
+                const suffix = this.getPossibleFileEndings(notebookTypeInfo.selector ?? []) ?? '';
+                for (let counter = 1; ; counter++) {
+                    const candidate = new URI()
+                        .withScheme('untitled')
+                        .withPath(`Untitled-notebook-${counter}${suffix}`)
+                        .withQuery(viewType);
+                    if (!this.notebookService.getNotebookEditorModel(candidate)) {
+                        resource = candidate;
+                        break;
+                    }
+                }
+            } else if (arg.untitledResource.scheme === 'untitled') {
+                resource = arg.untitledResource;
+            } else {
+                resource = arg.untitledResource.withScheme('untitled');
+                // hasAssociatedFilePath = true;
+            }
+        }
+
+        const notebookData = await this.resolveExistingNotebookData(resource, viewType!);
+
+        const notebookModel = await this.notebookService.createNotebookModel(notebookData, viewType, resource);
+
+        notebookModel.onDirtyChanged(() => this.onDidChangeDirtyEmitter.fire(notebookModel));
+        notebookModel.onDidSaveNotebook(() => this.onDidSaveNotebookEmitter.fire(notebookModel.uri.toComponents()));
+
+        return notebookModel;
+    }
+
+    protected async resolveExistingNotebookData(resource: URI, viewType: string): Promise<NotebookData> {
+        if (resource.scheme === 'untitled') {
+
+            return {
+                cells: [
+                    {
+                        cellKind: CellKind.Markup,
+                        language: 'markdown',
+                        outputs: [],
+                        source: ''
+                    }
+                ],
+                metadata: {}
+            };
+        } else {
+            const file = await this.fileService.readFile(resource);
+
+            const dataProvider = await this.notebookService.getNotebookDataProvider(viewType);
+            const notebook = await dataProvider.serializer.dataToNotebook(file.value);
+
+            return notebook;
+        }
+    }
+
+    protected getPossibleFileEndings(selectors: readonly NotebookFileSelector[]): string | undefined {
+        for (const selector of selectors) {
+            const ending = this.possibleFileEnding(selector);
+            if (ending) {
+                return ending;
+            }
+        }
+        return undefined;
+    }
+
+    protected possibleFileEnding(selector: NotebookFileSelector): string | undefined {
+
+        const pattern = /^.*(\.[a-zA-Z0-9_-]+)$/;
+
+        const candidate: string | undefined = typeof selector === 'string' ? selector : selector.filenamePattern;
+
+        if (candidate) {
+            const match = pattern.exec(candidate);
+            if (match) {
+                return match[1];
+            }
+        }
+
+        return undefined;
+    }
+
+}

package/src/browser/service/notebook-renderer-messaging-service.ts

@@ -0,0 +1,111 @@
+// *****************************************************************************
+// 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 { Emitter } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { Disposable } from '@theia/core/shared/vscode-languageserver-protocol';
+
+interface MessageToSend {
+    editorId: string;
+    rendererId: string;
+    message: unknown
+};
+
+export interface ScopedRendererMessaging extends Disposable {
+    /**
+     * Method called when a message is received. Should return a boolean
+     * indicating whether a renderer received it.
+     */
+    receiveMessageHandler?: (rendererId: string, message: unknown) => Promise<boolean>;
+
+    /**
+     * Sends a message to an extension from a renderer.
+     */
+    postMessage(rendererId: string, message: unknown): void;
+}
+
+@injectable()
+export class NotebookRendererMessagingService implements Disposable {
+
+    private readonly postMessageEmitter = new Emitter<MessageToSend>();
+    readonly onShouldPostMessage = this.postMessageEmitter.event;
+
+    private readonly activations = new Map<string /* rendererId */, undefined | MessageToSend[]>();
+    private readonly scopedMessaging = new Map<string /* editorId */, ScopedRendererMessaging>();
+
+    receiveMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean> {
+        if (editorId === undefined) {
+            const sends = [...this.scopedMessaging.values()].map(e => e.receiveMessageHandler?.(rendererId, message));
+            return Promise.all(sends).then(values => values.some(value => !!value));
+        }
+
+        return this.scopedMessaging.get(editorId)?.receiveMessageHandler?.(rendererId, message) ?? Promise.resolve(false);
+    }
+
+    prepare(rendererId: string): void {
+        if (this.activations.has(rendererId)) {
+            return;
+        }
+
+        const queue: MessageToSend[] = [];
+        this.activations.set(rendererId, queue);
+
+        // activate renderer
+        // this.extensionService.activateByEvent(`onRenderer:${rendererId}`).then(() => {
+        //     for (const message of queue) {
+        //         this.postMessageEmitter.fire(message);
+        //     }
+        //     this.activations.set(rendererId, undefined);
+        // });
+    }
+
+    public getScoped(editorId: string): ScopedRendererMessaging {
+        const existing = this.scopedMessaging.get(editorId);
+        if (existing) {
+            return existing;
+        }
+
+        const messaging: ScopedRendererMessaging = {
+            postMessage: (rendererId, message) => this.postMessage(editorId, rendererId, message),
+            dispose: () => this.scopedMessaging.delete(editorId),
+        };
+
+        this.scopedMessaging.set(editorId, messaging);
+        return messaging;
+    }
+
+    private postMessage(editorId: string, rendererId: string, message: unknown): void {
+        if (!this.activations.has(rendererId)) {
+            this.prepare(rendererId);
+        }
+
+        const activation = this.activations.get(rendererId);
+        const toSend = { rendererId, editorId, message };
+        if (activation === undefined) {
+            this.postMessageEmitter.fire(toSend);
+        } else {
+            activation.push(toSend);
+        }
+    }
+
+    dispose(): void {
+        this.postMessageEmitter.dispose();
+    }
+}