@theia/plugin-ext 1.40.1 → 1.41.0

package/src/main/browser/notebooks/notebook-kernels-main.ts

@@ -0,0 +1,291 @@
+// *****************************************************************************
+// 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 { CancellationToken, Disposable, Emitter, Event, URI } from '@theia/core';
+import { UriComponents } from '@theia/core/lib/common/uri';
+import { LanguageService } from '@theia/core/lib/browser/language-service';
+import { CellExecuteUpdateDto, CellExecutionCompleteDto, MAIN_RPC_CONTEXT, NotebookKernelDto, NotebookKernelsExt, NotebookKernelsMain } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { CellExecution, NotebookExecutionStateService, NotebookKernelChangeEvent, NotebookKernelService, NotebookService } from '@theia/notebook/lib/browser';
+import { combinedDisposable } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
+import { interfaces } from '@theia/core/shared/inversify';
+import { NotebookKernelSourceAction } from '@theia/notebook/lib/common';
+import { NotebookDto } from '../../../plugin/type-converters';
+
+abstract class NotebookKernel {
+    private readonly onDidChangeEmitter = new Emitter<NotebookKernelChangeEvent>();
+    private readonly preloads: { uri: URI; provides: readonly string[] }[];
+    readonly onDidChange: Event<NotebookKernelChangeEvent> = this.onDidChangeEmitter.event;
+
+    readonly id: string;
+    readonly viewType: string;
+    readonly extension: string;
+
+    implementsInterrupt: boolean;
+    label: string;
+    description?: string;
+    detail?: string;
+    supportedLanguages: string[];
+    implementsExecutionOrder: boolean;
+    localResourceRoot: URI;
+
+    public get preloadUris(): URI[] {
+        return this.preloads.map(p => p.uri);
+    }
+
+    public get preloadProvides(): string[] {
+        return this.preloads.map(p => p.provides).flat();
+    }
+
+    constructor(data: NotebookKernelDto, private languageService: LanguageService) {
+        this.id = data.id;
+        this.viewType = data.notebookType;
+        this.extension = data.extensionId;
+
+        this.implementsInterrupt = data.supportsInterrupt ?? false;
+        this.label = data.label;
+        this.description = data.description;
+        this.detail = data.detail;
+        this.supportedLanguages = (data.supportedLanguages && data.supportedLanguages.length > 0) ? data.supportedLanguages : languageService.languages.map(lang => lang.id);
+        this.implementsExecutionOrder = data.supportsExecutionOrder ?? false;
+        this.preloads = data.preloads?.map(u => ({ uri: URI.fromComponents(u.uri), provides: u.provides })) ?? [];
+    }
+
+    update(data: Partial<NotebookKernelDto>): void {
+
+        const event: NotebookKernelChangeEvent = Object.create(null);
+        if (data.label !== undefined) {
+            this.label = data.label;
+            event.label = true;
+        }
+        if (data.description !== undefined) {
+            this.description = data.description;
+            event.description = true;
+        }
+        if (data.detail !== undefined) {
+            this.detail = data.detail;
+            event.detail = true;
+        }
+        if (data.supportedLanguages !== undefined) {
+            this.supportedLanguages = (data.supportedLanguages && data.supportedLanguages.length > 0) ?
+                data.supportedLanguages :
+                this.languageService.languages.map(lang => lang.id);
+            event.supportedLanguages = true;
+        }
+        if (data.supportsExecutionOrder !== undefined) {
+            this.implementsExecutionOrder = data.supportsExecutionOrder;
+            event.hasExecutionOrder = true;
+        }
+        if (data.supportsInterrupt !== undefined) {
+            this.implementsInterrupt = data.supportsInterrupt;
+            event.hasInterruptHandler = true;
+        }
+        this.onDidChangeEmitter.fire(event);
+    }
+
+    abstract executeNotebookCellsRequest(uri: URI, cellHandles: number[]): Promise<void>;
+    abstract cancelNotebookCellExecution(uri: URI, cellHandles: number[]): Promise<void>;
+}
+
+class KernelDetectionTask {
+    constructor(readonly notebookType: string) { }
+}
+
+export interface KernelSourceActionProvider {
+    readonly viewType: string;
+    onDidChangeSourceActions?: Event<void>;
+    provideKernelSourceActions(): Promise<NotebookKernelSourceAction[]>;
+}
+
+export class NotebookKernelsMainImpl implements NotebookKernelsMain {
+
+    private readonly proxy: NotebookKernelsExt;
+
+    private readonly kernels = new Map<number, [kernel: NotebookKernel, registration: Disposable]>();
+
+    private readonly kernelDetectionTasks = new Map<number, [task: KernelDetectionTask, registration: Disposable]>();
+
+    private readonly kernelSourceActionProviders = new Map<number, [provider: KernelSourceActionProvider, registration: Disposable]>();
+    private readonly kernelSourceActionProvidersEventRegistrations = new Map<number, Disposable>();
+
+    private notebookKernelService: NotebookKernelService;
+    private notebookService: NotebookService;
+    private languageService: LanguageService;
+    private notebookExecutionStateService: NotebookExecutionStateService;
+
+    private readonly executions = new Map<number, CellExecution>();
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container,
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOK_KERNELS_EXT);
+
+        this.notebookKernelService = container.get(NotebookKernelService);
+        this.notebookExecutionStateService = container.get(NotebookExecutionStateService);
+        this.notebookService = container.get(NotebookService);
+        this.languageService = container.get(LanguageService);
+    }
+
+    $postMessage(handle: number, editorId: string | undefined, message: unknown): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+
+    async $addKernel(handle: number, data: NotebookKernelDto): Promise<void> {
+        const that = this;
+        const kernel = new class extends NotebookKernel {
+            async executeNotebookCellsRequest(uri: URI, handles: number[]): Promise<void> {
+                await that.proxy.$executeCells(handle, uri.toComponents(), handles);
+            }
+            async cancelNotebookCellExecution(uri: URI, handles: number[]): Promise<void> {
+                await that.proxy.$cancelCells(handle, uri.toComponents(), handles);
+            }
+        }(data, this.languageService);
+
+        const listener = this.notebookKernelService.onDidChangeSelectedKernel(e => {
+            if (e.oldKernel === kernel.id) {
+                this.proxy.$acceptNotebookAssociation(handle, e.notebook.toComponents(), false);
+            } else if (e.newKernel === kernel.id) {
+                this.proxy.$acceptNotebookAssociation(handle, e.notebook.toComponents(), true);
+            }
+        });
+
+        const registration = this.notebookKernelService.registerKernel(kernel);
+        this.kernels.set(handle, [kernel, combinedDisposable(listener, registration)]);
+
+    }
+
+    $updateKernel(handle: number, data: Partial<NotebookKernelDto>): void {
+        const tuple = this.kernels.get(handle);
+        if (tuple) {
+            tuple[0].update(data);
+        }
+    }
+
+    $removeKernel(handle: number): void {
+        const tuple = this.kernels.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this.kernels.delete(handle);
+        }
+    }
+
+    $updateNotebookPriority(handle: number, uri: UriComponents, value: number | undefined): void {
+        throw new Error('Method not implemented.');
+    }
+
+    $createExecution(handle: number, controllerId: string, uriComponents: UriComponents, cellHandle: number): void {
+        const uri = URI.fromComponents(uriComponents);
+        const notebook = this.notebookService.getNotebookEditorModel(uri);
+        if (!notebook) {
+            throw new Error(`Notebook not found: ${uri.toString()}`);
+        }
+
+        const kernel = this.notebookKernelService.getMatchingKernel(notebook);
+        if (!kernel.selected || kernel.selected.id !== controllerId) {
+            throw new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`);
+        }
+        const execution = this.notebookExecutionStateService.createCellExecution(uri, cellHandle);
+        execution.confirm();
+        this.executions.set(handle, execution);
+    }
+
+    $updateExecution(handle: number, updates: CellExecuteUpdateDto[]): void {
+        const execution = this.executions.get(handle);
+        execution?.update(updates.map(NotebookDto.fromCellExecuteUpdateDto));
+
+    }
+    $completeExecution(handle: number, data: CellExecutionCompleteDto): void {
+        try {
+            const execution = this.executions.get(handle);
+            execution?.complete(NotebookDto.fromCellExecuteCompleteDto(data));
+        } finally {
+            this.executions.delete(handle);
+        }
+
+    }
+
+    // TODO implement notebook execution (special api for executing full notebook instead of just cells)
+    $createNotebookExecution(handle: number, controllerId: string, uri: UriComponents): void {
+        throw new Error('Method not implemented.');
+    }
+    $beginNotebookExecution(handle: number): void {
+        throw new Error('Method not implemented.');
+    }
+    $completeNotebookExecution(handle: number): void {
+        throw new Error('Method not implemented.');
+    }
+
+    async $addKernelDetectionTask(handle: number, notebookType: string): Promise<void> {
+        const kernelDetectionTask = new KernelDetectionTask(notebookType);
+        const registration = this.notebookKernelService.registerNotebookKernelDetectionTask(kernelDetectionTask);
+        this.kernelDetectionTasks.set(handle, [kernelDetectionTask, registration]);
+    }
+    $removeKernelDetectionTask(handle: number): void {
+        const tuple = this.kernelDetectionTasks.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this.kernelDetectionTasks.delete(handle);
+        }
+    }
+    async $addKernelSourceActionProvider(handle: number, eventHandle: number, notebookType: string): Promise<void> {
+        const kernelSourceActionProvider: KernelSourceActionProvider = {
+            viewType: notebookType,
+            provideKernelSourceActions: async () => {
+                const actions = await this.proxy.$provideKernelSourceActions(handle, CancellationToken.None);
+
+                return actions.map(action => ({
+                    label: action.label,
+                    command: action.command,
+                    description: action.description,
+                    detail: action.detail,
+                    documentation: action.documentation,
+                }));
+            }
+        };
+
+        if (typeof eventHandle === 'number') {
+            const emitter = new Emitter<void>();
+            this.kernelSourceActionProvidersEventRegistrations.set(eventHandle, emitter);
+            kernelSourceActionProvider.onDidChangeSourceActions = emitter.event;
+        }
+
+        const registration = this.notebookKernelService.registerKernelSourceActionProvider(notebookType, kernelSourceActionProvider);
+        this.kernelSourceActionProviders.set(handle, [kernelSourceActionProvider, registration]);
+    }
+
+    $removeKernelSourceActionProvider(handle: number, eventHandle: number): void {
+        const tuple = this.kernelSourceActionProviders.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this.kernelSourceActionProviders.delete(handle);
+        }
+        if (typeof eventHandle === 'number') {
+            this.kernelSourceActionProvidersEventRegistrations.delete(eventHandle);
+        }
+    }
+    $emitNotebookKernelSourceActionsChangeEvent(eventHandle: number): void {
+    }
+
+    dispose(): void {
+        this.kernels.forEach(kernel => kernel[1].dispose());
+    }
+
+}

package/src/main/browser/notebooks/notebook-renderers-main.ts

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// 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 { DisposableCollection } from '@theia/core';
+import { interfaces } from '@theia/core/shared/inversify';
+import { NotebookRendererMessagingService } from '@theia/notebook/lib/browser';
+import { MAIN_RPC_CONTEXT, NotebookRenderersExt, NotebookRenderersMain } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+
+export class NotebookRenderersMainImpl implements NotebookRenderersMain {
+    private readonly proxy: NotebookRenderersExt;
+    private readonly rendererMessagingService: NotebookRendererMessagingService;
+
+    private readonly disposables = new DisposableCollection();
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOK_RENDERERS_EXT);
+        this.rendererMessagingService = container.get(NotebookRendererMessagingService);
+        this.rendererMessagingService.onShouldPostMessage(e => {
+            this.proxy.$postRendererMessage(e.editorId, e.rendererId, e.message);
+        });
+    }
+
+    $postMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean> {
+        return this.rendererMessagingService.receiveMessage(editorId, rendererId, message);
+    }
+
+    dispose(): void {
+        this.disposables.dispose();
+    }
+}

package/src/main/browser/notebooks/notebooks-main.ts

@@ -0,0 +1,124 @@
+// *****************************************************************************
+// 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 { CancellationToken, DisposableCollection, Emitter } from '@theia/core';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { NotebookCellStatusBarItemList, NotebookCellStatusBarItemProvider, NotebookData, NotebookExtensionDescription, TransientOptions } from '@theia/notebook/lib/common';
+import { NotebookService } from '@theia/notebook/lib/browser';
+import { Disposable } from '@theia/plugin';
+import { MAIN_RPC_CONTEXT, NotebooksExt, NotebooksMain } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { NotebookDto } from './notebook-dto';
+import { UriComponents } from '@theia/core/lib/common/uri';
+import { HostedPluginSupport } from '../../../hosted/browser/hosted-plugin';
+
+export class NotebooksMainImpl implements NotebooksMain {
+
+    private readonly disposables = new DisposableCollection();
+
+    private readonly proxy: NotebooksExt;
+    private readonly notebookSerializer = new Map<number, Disposable>();
+    private readonly notebookCellStatusBarRegistrations = new Map<number, Disposable>();
+
+    constructor(
+        rpc: RPCProtocol,
+        private notebookService: NotebookService,
+        plugins: HostedPluginSupport
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOKS_EXT);
+        notebookService.onNotebookSerializer(async event => plugins.activateByEvent(event));
+        notebookService.markReady();
+    }
+
+    dispose(): void {
+        this.disposables.dispose();
+        for (const disposable of this.notebookSerializer.values()) {
+            disposable.dispose();
+        }
+    }
+
+    $registerNotebookSerializer(handle: number, extension: NotebookExtensionDescription, viewType: string, options: TransientOptions): void {
+        const disposables = new DisposableCollection();
+
+        disposables.push(this.notebookService.registerNotebookSerializer(viewType, extension, {
+            options,
+            dataToNotebook: async (data: BinaryBuffer): Promise<NotebookData> => {
+                const dto = await this.proxy.$dataToNotebook(handle, data, CancellationToken.None);
+                return NotebookDto.fromNotebookDataDto(dto);
+            },
+            notebookToData: (data: NotebookData): Promise<BinaryBuffer> =>
+                this.proxy.$notebookToData(handle, NotebookDto.toNotebookDataDto(data), CancellationToken.None)
+
+        }));
+
+        this.notebookSerializer.set(handle, disposables);
+    }
+
+    $unregisterNotebookSerializer(handle: number): void {
+        this.notebookSerializer.get(handle)?.dispose();
+        this.notebookSerializer.delete(handle);
+    }
+
+    $emitCellStatusBarEvent(eventHandle: number): void {
+        const emitter = this.notebookCellStatusBarRegistrations.get(eventHandle);
+        if (emitter instanceof Emitter) {
+            emitter.fire(undefined);
+        }
+    }
+
+    async $registerNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined, viewType: string): Promise<void> {
+        const that = this;
+        const provider: NotebookCellStatusBarItemProvider = {
+            async provideCellStatusBarItems(uri: UriComponents, index: number, token: CancellationToken): Promise<NotebookCellStatusBarItemList | undefined> {
+                const result = await that.proxy.$provideNotebookCellStatusBarItems(handle, uri, index, token);
+                return {
+                    items: result?.items ?? [],
+                    dispose(): void {
+                        if (result) {
+                            that.proxy.$releaseNotebookCellStatusBarItems(result.cacheId);
+                        }
+                    }
+                };
+            },
+            viewType
+        };
+
+        if (typeof eventHandle === 'number') {
+            const emitter = new Emitter<void>();
+            this.notebookCellStatusBarRegistrations.set(eventHandle, emitter);
+            provider.onDidChangeStatusBarItems = emitter.event;
+        }
+
+        // const disposable = this._cellStatusBarService.registerCellStatusBarItemProvider(provider);
+        // this.notebookCellStatusBarRegistrations.set(handle, disposable);
+    }
+
+    async $unregisterNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined): Promise<void> {
+        // eslint-disable-next-line @typescript-eslint/no-shadow
+        const unregisterThing = (statusBarHandle: number) => {
+            const entry = this.notebookCellStatusBarRegistrations.get(statusBarHandle);
+            if (entry) {
+                this.notebookCellStatusBarRegistrations.get(statusBarHandle)?.dispose();
+                this.notebookCellStatusBarRegistrations.delete(statusBarHandle);
+            }
+        };
+        unregisterThing(handle);
+        if (typeof eventHandle === 'number') {
+            unregisterThing(eventHandle);
+        }
+    }
+}
+

package/src/main/browser/notebooks/renderers/cell-output-webview.tsx

@@ -0,0 +1,198 @@
+// *****************************************************************************
+// 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 * as React from '@theia/core/shared/react';
+import { inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
+import { NotebookRendererMessagingService, CellOutputWebview, NotebookRendererRegistry, NotebookEditorWidgetService } from '@theia/notebook/lib/browser';
+import { v4 } from 'uuid';
+import { NotebookCellModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-model';
+import { WebviewWidget } from '../../webview/webview';
+import { Message, WidgetManager } from '@theia/core/lib/browser';
+import { outputWebviewPreload, PreloadContext } from './output-webview-internal';
+import { WorkspaceTrustService } from '@theia/workspace/lib/browser';
+import { ChangePreferredMimetypeMessage, FromWebviewMessage, OutputChangedMessage } from './webview-communication';
+import { CellUri, NotebookCellOutputsSplice } from '@theia/notebook/lib/common';
+import { Disposable, DisposableCollection, nls, QuickPickService } from '@theia/core';
+import { NotebookCellOutputModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-output-model';
+
+const CellModel = Symbol('CellModel');
+
+export function createCellOutputWebviewContainer(ctx: interfaces.Container, cell: NotebookCellModel): interfaces.Container {
+    const child = ctx.createChild();
+    child.bind(CellModel).toConstantValue(cell);
+    child.bind(CellOutputWebviewImpl).toSelf().inSingletonScope();
+    return child;
+}
+
+@injectable()
+export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
+
+    @inject(NotebookRendererMessagingService)
+    protected readonly messagingService: NotebookRendererMessagingService;
+
+    @inject(CellModel)
+    protected readonly cell: NotebookCellModel;
+
+    @inject(WidgetManager)
+    protected readonly widgetManager: WidgetManager;
+
+    @inject(WorkspaceTrustService)
+    protected readonly workspaceTrustService: WorkspaceTrustService;
+
+    @inject(NotebookRendererRegistry)
+    protected readonly notebookRendererRegistry: NotebookRendererRegistry;
+
+    @inject(NotebookEditorWidgetService)
+    protected readonly notebookEditorWidgetService: NotebookEditorWidgetService;
+
+    @inject(QuickPickService)
+    protected readonly quickPickService: QuickPickService;
+
+    readonly id = v4();
+
+    protected readonly elementRef = React.createRef<HTMLDivElement>();
+    protected outputPresentationListeners: DisposableCollection = new DisposableCollection();
+
+    protected webviewWidget: WebviewWidget;
+
+    @postConstruct()
+    protected async init(): Promise<void> {
+        this.cell.onDidChangeOutputs(outputChange => this.updateOutput(outputChange));
+
+        this.webviewWidget = await this.widgetManager.getOrCreateWidget(WebviewWidget.FACTORY_ID, { id: this.id });
+        this.webviewWidget.setContentOptions({ allowScripts: true });
+        this.webviewWidget.setHTML(await this.createWebviewContent());
+
+        this.webviewWidget.onMessage((message: FromWebviewMessage) => {
+            this.handleWebviewMessage(message);
+        });
+    }
+
+    render(): React.JSX.Element {
+        return <div className='theia-notebook-cell-output-webview' ref={this.elementRef}></div>;
+    }
+
+    attachWebview(): void {
+        if (this.elementRef.current) {
+            this.webviewWidget.processMessage(new Message('before-attach'));
+            this.elementRef.current.appendChild(this.webviewWidget.node);
+            this.webviewWidget.processMessage(new Message('after-attach'));
+            this.webviewWidget.setIframeHeight(0);
+        }
+    }
+
+    isAttached(): boolean {
+        return this.elementRef.current?.contains(this.webviewWidget.node) ?? false;
+    }
+
+    updateOutput(update: NotebookCellOutputsSplice): void {
+        if (this.cell.outputs.length > 0) {
+            if (this.webviewWidget.isHidden) {
+                this.webviewWidget.show();
+            }
+
+            this.outputPresentationListeners.dispose();
+            this.outputPresentationListeners = new DisposableCollection();
+            for (const output of this.cell.outputs) {
+                this.outputPresentationListeners.push(output.onRequestOutputPresentationChange(() => this.requestOutputPresentationUpdate(output)));
+            }
+
+            const updateOutputMessage: OutputChangedMessage = {
+                type: 'outputChanged',
+                newOutputs: update.newOutputs.map(output => ({
+                    id: output.outputId,
+                    items: output.outputs.map(item => ({ mime: item.mime, data: item.data.buffer })),
+                    metadata: output.metadata
+                })),
+                deletedOutputIds: this.cell.outputs.slice(update.start, update.start + update.deleteCount).map(output => output.outputId)
+            };
+
+            this.webviewWidget.sendMessage(updateOutputMessage);
+        }
+    }
+
+    private async requestOutputPresentationUpdate(output: NotebookCellOutputModel): Promise<void> {
+        const selectedMime = await this.quickPickService.show(
+            output.outputs.map(item => ({label: item.mime})),
+            {description: nls.localizeByDefault('Select mimetype to render for current output' )});
+        if (selectedMime) {
+            this.webviewWidget.sendMessage({
+                type: 'changePreferredMimetype',
+                outputId: output.outputId,
+                mimeType: selectedMime.label
+            } as ChangePreferredMimetypeMessage);
+        }
+    }
+
+    private handleWebviewMessage(message: FromWebviewMessage): void {
+        switch (message.type) {
+            case 'initialized':
+                this.updateOutput({newOutputs: this.cell.outputs, start: 0, deleteCount: 0});
+                break;
+            case 'customRendererMessage':
+                this.messagingService.getScoped('').postMessage(message.rendererId, message.message);
+                break;
+            case 'didRenderOutput':
+                this.webviewWidget.setIframeHeight(message.contentHeight + 5);
+                break;
+            case 'did-scroll-wheel':
+                this.notebookEditorWidgetService.getNotebookEditor(`notebook:${CellUri.parse(this.cell.uri)?.notebook}`)?.node.scrollBy(message.deltaX, message.deltaY);
+                break;
+        }
+    }
+
+    private async createWebviewContent(): Promise<string> {
+        const isWorkspaceTrusted = await this.workspaceTrustService.getWorkspaceTrust();
+        const preloads = this.preloadsScriptString(isWorkspaceTrusted);
+        const content = `
+            <html>
+                <head>
+                    <meta charset="UTF-8">
+                </head>
+                <body>
+                    <script type="module">${preloads}</script>
+                </body>
+            </html>
+        `;
+        return content;
+    }
+
+    private preloadsScriptString(isWorkspaceTrusted: boolean): string {
+        const ctx: PreloadContext = {
+            isWorkspaceTrusted,
+            rendererData: this.notebookRendererRegistry.notebookRenderers,
+            renderOptions: { // TODO these should be changeable in the settings
+                lineLimit: 30,
+                outputScrolling: false,
+                outputWordWrap: false,
+            }
+        };
+        // TS will try compiling `import()` in webviewPreloads, so use a helper function instead
+        // of using `import(...)` directly
+        return `
+            const __import = (x) => import(x);
+            (${outputWebviewPreload})(JSON.parse(decodeURIComponent("${encodeURIComponent(JSON.stringify(ctx))}")))`;
+    }
+
+    dispose(): void {
+        this.outputPresentationListeners.dispose();
+        this.webviewWidget.dispose();
+    }
+}