@theia/plugin-ext 1.40.0 → 1.41.0

package/src/main/browser/notebooks/notebook-documents-and-editors-main.ts

@@ -0,0 +1,238 @@
+// *****************************************************************************
+// 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 } from '@theia/core';
+import { interfaces } from '@theia/core/shared/inversify';
+import { UriComponents } from '@theia/core/lib/common/uri';
+import { NotebookEditorWidget, NotebookService, NotebookEditorWidgetService } from '@theia/notebook/lib/browser';
+import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { MAIN_RPC_CONTEXT, NotebookDocumentsAndEditorsDelta, NotebookDocumentsAndEditorsMain, NotebookModelAddedData, NotebooksExt } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { NotebookDto } from './notebook-dto';
+import { WidgetManager } from '@theia/core/lib/browser';
+import { NotebookEditorsMainImpl } from './notebook-editors-main';
+import { NotebookDocumentsMainImpl } from './notebook-documents-main';
+import { diffMaps, diffSets } from '../../../common/collections';
+import { Mutex } from 'async-mutex';
+
+interface NotebookAndEditorDelta {
+    removedDocuments: UriComponents[];
+    addedDocuments: NotebookModel[];
+    removedEditors: string[];
+    addedEditors: NotebookEditorWidget[];
+    newActiveEditor?: string | null;
+    visibleEditors?: string[];
+}
+
+class NotebookAndEditorState {
+    static delta(before: NotebookAndEditorState | undefined, after: NotebookAndEditorState): NotebookAndEditorDelta {
+        if (!before) {
+            return {
+                addedDocuments: [...after.documents],
+                removedDocuments: [],
+                addedEditors: [...after.textEditors.values()],
+                removedEditors: [],
+                visibleEditors: [...after.visibleEditors].map(editor => editor[0])
+            };
+        }
+        const documentDelta = diffSets(before.documents, after.documents);
+        const editorDelta = diffMaps(before.textEditors, after.textEditors);
+
+        const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
+        const visibleEditorDelta = diffMaps(before.visibleEditors, after.visibleEditors);
+
+        return {
+            addedDocuments: documentDelta.added,
+            removedDocuments: documentDelta.removed.map(e => e.uri.toComponents()),
+            addedEditors: editorDelta.added,
+            removedEditors: editorDelta.removed.map(removed => removed.id),
+            newActiveEditor: newActiveEditor,
+            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0
+                ? undefined
+                : [...after.visibleEditors].map(editor => editor[0])
+        };
+    }
+
+    constructor(
+        readonly documents: Set<NotebookModel>,
+        readonly textEditors: Map<string, NotebookEditorWidget>,
+        readonly activeEditor: string | null | undefined,
+        readonly visibleEditors: Map<string, NotebookEditorWidget>
+    ) {
+        //
+    }
+}
+
+export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain {
+
+    protected readonly proxy: NotebooksExt;
+    protected readonly disposables = new DisposableCollection();
+
+    protected readonly editorListeners = new Map<string, Disposable[]>();
+
+    protected currentState?: NotebookAndEditorState;
+    protected readonly updateMutex = new Mutex();
+
+    protected readonly notebookService: NotebookService;
+    protected readonly notebookEditorService: NotebookEditorWidgetService;
+    protected readonly WidgetManager: WidgetManager;
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container,
+        protected readonly notebookDocumentsMain: NotebookDocumentsMainImpl,
+        protected readonly notebookEditorsMain: NotebookEditorsMainImpl
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOKS_EXT);
+
+        this.notebookService = container.get(NotebookService);
+        this.notebookEditorService = container.get(NotebookEditorWidgetService);
+        this.WidgetManager = container.get(WidgetManager);
+
+        this.notebookService.onDidAddNotebookDocument(async () => this.updateState(), this, this.disposables);
+        this.notebookService.onDidRemoveNotebookDocument(async () => this.updateState(), this, this.disposables);
+        // this.WidgetManager.onActiveEditorChanged(() => this.updateState(), this, this.disposables);
+        this.notebookEditorService.onDidAddNotebookEditor(async editor => this.handleEditorAdd(editor), this, this.disposables);
+        this.notebookEditorService.onDidRemoveNotebookEditor(async editor => this.handleEditorRemove(editor), this, this.disposables);
+        this.notebookEditorService.onFocusedEditorChanged(async editor => this.updateState(editor), this, this.disposables);
+    }
+
+    dispose(): void {
+        this.notebookDocumentsMain.dispose();
+        this.notebookEditorsMain.dispose();
+        this.disposables.dispose();
+        this.editorListeners.forEach(listeners => listeners.forEach(listener => listener.dispose()));
+    }
+
+    private async handleEditorAdd(editor: NotebookEditorWidget): Promise<void> {
+        const listeners = this.editorListeners.get(editor.id);
+        const disposable = editor.onDidChangeModel(() => this.updateState());
+        if (listeners) {
+            listeners.push(disposable);
+        } else {
+            this.editorListeners.set(editor.id, [disposable]);
+        }
+        await this.updateState();
+    }
+
+    private handleEditorRemove(editor: NotebookEditorWidget): void {
+        const listeners = this.editorListeners.get(editor.id);
+        listeners?.forEach(listener => listener.dispose());
+        this.editorListeners.delete(editor.id);
+        this.updateState();
+    }
+
+    private async updateState(focusedEditor?: NotebookEditorWidget): Promise<void> {
+        await this.updateMutex.runExclusive(async () => this.doUpdateState(focusedEditor));
+    }
+
+    private async doUpdateState(focusedEditor?: NotebookEditorWidget): Promise<void> {
+
+        const editors = new Map<string, NotebookEditorWidget>();
+        const visibleEditorsMap = new Map<string, NotebookEditorWidget>();
+
+        for (const editor of this.notebookEditorService.listNotebookEditors()) {
+            if (editor.model) {
+                editors.set(editor.id, editor);
+            }
+        }
+
+        const activeNotebookEditor = this.notebookEditorService.currentFocusedEditor;
+        let activeEditor: string | null = null;
+        if (activeNotebookEditor) {
+            activeEditor = activeNotebookEditor.id;
+        } else if (focusedEditor?.model) {
+            activeEditor = focusedEditor.id;
+        }
+        if (activeEditor && !editors.has(activeEditor)) {
+            activeEditor = null;
+        }
+
+        const notebookEditors = this.WidgetManager.getWidgets(NotebookEditorWidget.ID) as NotebookEditorWidget[];
+        for (const notebookEditor of notebookEditors) {
+            if (notebookEditor?.model && editors.has(notebookEditor.id) && notebookEditor.isVisible) {
+                visibleEditorsMap.set(notebookEditor.id, notebookEditor);
+            }
+        }
+
+        const newState = new NotebookAndEditorState(
+            new Set(this.notebookService.listNotebookDocuments()),
+            editors,
+            activeEditor, visibleEditorsMap);
+        await this.onDelta(NotebookAndEditorState.delta(this.currentState, newState));
+        this.currentState = newState;
+    }
+
+    private async onDelta(delta: NotebookAndEditorDelta): Promise<void> {
+        if (NotebooksAndEditorsMain._isDeltaEmpty(delta)) {
+            return;
+        }
+
+        const dto: NotebookDocumentsAndEditorsDelta = {
+            removedDocuments: delta.removedDocuments,
+            removedEditors: delta.removedEditors,
+            newActiveEditor: delta.newActiveEditor,
+            visibleEditors: delta.visibleEditors,
+            addedDocuments: delta.addedDocuments.map(NotebooksAndEditorsMain.asModelAddData),
+            // addedEditors: delta.addedEditors.map(this.asEditorAddData, this),
+        };
+
+        // send to extension FIRST
+        await this.proxy.$acceptDocumentsAndEditorsDelta(dto);
+
+        // handle internally
+        this.notebookEditorsMain.handleEditorsRemoved(delta.removedEditors);
+        this.notebookDocumentsMain.handleNotebooksRemoved(delta.removedDocuments);
+        this.notebookDocumentsMain.handleNotebooksAdded(delta.addedDocuments);
+        this.notebookEditorsMain.handleEditorsAdded(delta.addedEditors);
+    }
+
+    private static _isDeltaEmpty(delta: NotebookAndEditorDelta): boolean {
+        if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
+            return false;
+        }
+        if (delta.removedDocuments !== undefined && delta.removedDocuments.length > 0) {
+            return false;
+        }
+        if (delta.addedEditors !== undefined && delta.addedEditors.length > 0) {
+            return false;
+        }
+        if (delta.removedEditors !== undefined && delta.removedEditors.length > 0) {
+            return false;
+        }
+        if (delta.visibleEditors !== undefined && delta.visibleEditors.length > 0) {
+            return false;
+        }
+        if (delta.newActiveEditor !== undefined) {
+            return false;
+        }
+        return true;
+    }
+
+    private static asModelAddData(e: NotebookModel): NotebookModelAddedData {
+        return {
+            viewType: e.viewType,
+            uri: e.uri.toComponents(),
+            metadata: e.metadata,
+            versionId: 1, // TODO implement versionID support
+            cells: e.cells.map(NotebookDto.toNotebookCellDto)
+        };
+    }
+}

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

@@ -0,0 +1,166 @@
+// *****************************************************************************
+// 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 { URI, UriComponents } from '@theia/core/lib/common/uri';
+import { interfaces } from '@theia/core/shared/inversify';
+import { NotebookModelResolverService } from '@theia/notebook/lib/browser';
+import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { NotebookCellsChangeType } from '@theia/notebook/lib/common';
+import { MAIN_RPC_CONTEXT, NotebookCellDto, NotebookCellsChangedEventDto, NotebookDataDto, NotebookDocumentsExt, NotebookDocumentsMain } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { NotebookDto } from './notebook-dto';
+
+export class NotebookDocumentsMainImpl implements NotebookDocumentsMain {
+
+    private readonly disposables = new DisposableCollection();
+
+    private readonly proxy: NotebookDocumentsExt;
+    private readonly documentEventListenersMapping = new Map<string, DisposableCollection>();
+
+    private readonly notebookModelResolverService: NotebookModelResolverService;
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_EXT);
+        this.notebookModelResolverService = container.get(NotebookModelResolverService);
+
+        // forward dirty and save events
+        this.disposables.push(this.notebookModelResolverService.onDidChangeDirty(model => this.proxy.$acceptDirtyStateChanged(model.uri.toComponents(), model.isDirty())));
+        this.disposables.push(this.notebookModelResolverService.onDidSaveNotebook(e => this.proxy.$acceptModelSaved(e)));
+
+    }
+
+    dispose(): void {
+        this.disposables.dispose();
+        // this.modelReferenceCollection.dispose();
+        this.documentEventListenersMapping.forEach(value => value.dispose());
+    }
+
+    handleNotebooksAdded(notebooks: readonly NotebookModel[]): void {
+
+        for (const textModel of notebooks) {
+            const disposableStore = new DisposableCollection();
+            disposableStore.push(textModel.onDidChangeContent(event => {
+
+                const eventDto: NotebookCellsChangedEventDto = {
+                    versionId: 1, // TODO implement version ID support
+                    rawEvents: []
+                };
+
+                for (const e of event.rawEvents) {
+
+                    switch (e.kind) {
+                        case NotebookCellsChangeType.ModelChange:
+                            eventDto.rawEvents.push({
+                                kind: e.kind,
+                                changes: e.changes.map(diff =>
+                                    [diff[0], diff[1], diff[2].map(NotebookDto.toNotebookCellDto)] as [number, number, NotebookCellDto[]])
+                            });
+                            break;
+                        case NotebookCellsChangeType.Move:
+                            eventDto.rawEvents.push({
+                                kind: e.kind,
+                                index: e.index,
+                                length: e.length,
+                                newIdx: e.newIdx,
+                            });
+                            break;
+                        case NotebookCellsChangeType.Output:
+                            eventDto.rawEvents.push({
+                                kind: e.kind,
+                                index: e.index,
+                                outputs: e.outputs.map(NotebookDto.toNotebookOutputDto)
+                            });
+                            break;
+                        case NotebookCellsChangeType.OutputItem:
+                            eventDto.rawEvents.push({
+                                kind: e.kind,
+                                index: e.index,
+                                outputId: e.outputId,
+                                outputItems: e.outputItems.map(NotebookDto.toNotebookOutputItemDto),
+                                append: e.append
+                            });
+                            break;
+                        case NotebookCellsChangeType.ChangeCellLanguage:
+                        case NotebookCellsChangeType.ChangeCellContent:
+                        case NotebookCellsChangeType.ChangeCellMetadata:
+                        case NotebookCellsChangeType.ChangeCellInternalMetadata:
+                            eventDto.rawEvents.push(e);
+                            break;
+                    }
+                }
+
+                const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
+
+                // using the model resolver service to know if the model is dirty or not.
+                // assuming this is the first listener it can mean that at first the model
+                // is marked as dirty and that another event is fired
+                this.proxy.$acceptModelChanged(
+                    textModel.uri.toComponents(),
+                    eventDto,
+                    textModel.isDirty(),
+                    hasDocumentMetadataChangeEvent ? textModel.metadata : undefined
+                );
+            }));
+
+            this.documentEventListenersMapping.set(textModel.uri.toString(), disposableStore);
+        }
+    }
+
+    handleNotebooksRemoved(uris: UriComponents[]): void {
+        for (const uri of uris) {
+            this.documentEventListenersMapping.get(uri.toString())?.dispose();
+            this.documentEventListenersMapping.delete(uri.toString());
+        }
+    }
+
+    async $tryCreateNotebook(options: { viewType: string; content?: NotebookDataDto }): Promise<UriComponents> {
+        const ref = await this.notebookModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
+
+        // untitled notebooks are disposed when they get saved. we should not hold a reference
+        // to such a disposed notebook and therefore dispose the reference as well
+        // ref.onWillDispose(() => {
+        //     ref.dispose();
+        // });
+
+        // untitled notebooks are dirty by default
+        this.proxy.$acceptDirtyStateChanged(ref.uri.toComponents(), true);
+
+        // apply content changes... slightly HACKY -> this triggers a change event
+        // if (options.content) {
+        //     const data = NotebookDto.fromNotebookDataDto(options.content);
+        //     ref.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
+        // }
+        return ref.uri.toComponents();
+    }
+
+    async $tryOpenNotebook(uriComponents: UriComponents): Promise<UriComponents> {
+        const uri = URI.fromComponents(uriComponents);
+        return uri.toComponents();
+    }
+
+    async $trySaveNotebook(uriComponents: UriComponents): Promise<boolean> {
+        const uri = URI.fromComponents(uriComponents);
+
+        const ref = await this.notebookModelResolverService.resolve(uri);
+        await ref.save({});
+        ref.dispose();
+        return true;
+    }
+}

package/src/main/browser/notebooks/notebook-dto.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 { OS } from '@theia/core';
+import * as notebookCommon from '@theia/notebook/lib/common';
+import { NotebookCellModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-model';
+import * as rpc from '../../../common';
+
+export namespace NotebookDto {
+
+    export function toNotebookOutputItemDto(item: notebookCommon.CellOutputItem): rpc.NotebookOutputItemDto {
+        return {
+            mime: item.mime,
+            valueBytes: item.data
+        };
+    }
+
+    export function toNotebookOutputDto(output: notebookCommon.CellOutput): rpc.NotebookOutputDto {
+        return {
+            outputId: output.outputId,
+            metadata: output.metadata,
+            items: output.outputs.map(toNotebookOutputItemDto)
+        };
+    }
+
+    export function toNotebookCellDataDto(cell: notebookCommon.CellData): rpc.NotebookCellDataDto {
+        return {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            source: cell.source,
+            internalMetadata: cell.internalMetadata,
+            metadata: cell.metadata,
+            outputs: cell.outputs.map(toNotebookOutputDto)
+        };
+    }
+
+    export function toNotebookDataDto(data: notebookCommon.NotebookData): rpc.NotebookDataDto {
+        return {
+            metadata: data.metadata,
+            cells: data.cells.map(toNotebookCellDataDto)
+        };
+    }
+
+    export function fromNotebookOutputItemDto(item: rpc.NotebookOutputItemDto): notebookCommon.CellOutputItem {
+        return {
+            mime: item.mime,
+            data: item.valueBytes
+        };
+    }
+
+    export function fromNotebookOutputDto(output: rpc.NotebookOutputDto): notebookCommon.CellOutput {
+        return {
+            outputId: output.outputId,
+            metadata: output.metadata,
+            outputs: output.items.map(fromNotebookOutputItemDto)
+        };
+    }
+
+    export function fromNotebookCellDataDto(cell: rpc.NotebookCellDataDto): notebookCommon.CellData {
+        return {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            source: cell.source,
+            outputs: cell.outputs.map(fromNotebookOutputDto),
+            metadata: cell.metadata,
+            internalMetadata: cell.internalMetadata
+        };
+    }
+
+    export function fromNotebookDataDto(data: rpc.NotebookDataDto): notebookCommon.NotebookData {
+        return {
+            metadata: data.metadata,
+            cells: data.cells.map(fromNotebookCellDataDto)
+        };
+    }
+
+    export function toNotebookCellDto(cell: NotebookCellModel): rpc.NotebookCellDto {
+        const eol = OS.backend.isWindows ? '\r\n' : '\n';
+        return {
+            handle: cell.handle,
+            uri: cell.uri.toComponents(),
+            source: cell.textBuffer.split(eol),
+            eol,
+            language: cell.language,
+            cellKind: cell.cellKind,
+            outputs: cell.outputs.map(toNotebookOutputDto),
+            metadata: cell.metadata,
+            internalMetadata: cell.internalMetadata,
+        };
+    }
+
+    // export function fromCellExecuteUpdateDto(data: extHostProtocol.ICellExecuteUpdateDto): ICellExecuteUpdate {
+    //     if (data.editType === CellExecutionUpdateType.Output) {
+    //         return {
+    //             editType: data.editType,
+    //             cellHandle: data.cellHandle,
+    //             append: data.append,
+    //             outputs: data.outputs.map(fromNotebookOutputDto)
+    //         };
+    //     } else if (data.editType === CellExecutionUpdateType.OutputItems) {
+    //         return {
+    //             editType: data.editType,
+    //             append: data.append,
+    //             outputId: data.outputId,
+    //             items: data.items.map(fromNotebookOutputItemDto)
+    //         };
+    //     } else {
+    //         return data;
+    //     }
+    // }
+
+    // export function fromCellExecuteCompleteDto(data: extHostProtocol.ICellExecutionCompleteDto): ICellExecutionComplete {
+    //     return data;
+    // }
+
+    // export function fromCellEditOperationDto(edit: extHostProtocol.ICellEditOperationDto): notebookCommon.ICellEditOperation {
+    //     if (edit.editType === notebookCommon.CellEditType.Replace) {
+    //         return {
+    //             editType: edit.editType,
+    //             index: edit.index,
+    //             count: edit.count,
+    //             cells: edit.cells.map(fromNotebookCellDataDto)
+    //         };
+    //     } else {
+    //         return edit;
+    //     }
+    // }
+}

package/src/main/browser/notebooks/notebook-editors-main.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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { UriComponents, URI } from '@theia/core/lib/common/uri';
+import { CellRange } from '@theia/notebook/lib/common';
+import { NotebookEditorWidget } from '@theia/notebook/lib/browser';
+import { MAIN_RPC_CONTEXT, NotebookDocumentShowOptions, NotebookEditorRevealType, NotebookEditorsExt, NotebookEditorsMain } from '../../../common';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { interfaces } from '@theia/core/shared/inversify';
+import { open, OpenerService } from '@theia/core/lib/browser';
+
+export class NotebookEditorsMainImpl implements NotebookEditorsMain {
+
+    protected readonly proxy: NotebookEditorsExt;
+    protected readonly openerService: OpenerService;
+
+    protected readonly mainThreadEditors = new Map<string, NotebookEditorWidget>();
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTEBOOK_EDITORS_EXT);
+        this.openerService = container.get(OpenerService);
+    }
+
+    async $tryShowNotebookDocument(uriComponents: UriComponents, viewType: string, options: NotebookDocumentShowOptions): Promise<string> {
+        const editor = await open(this.openerService, URI.fromComponents(uriComponents), {});
+        return (editor as NotebookEditorWidget).id;
+    }
+    $tryRevealRange(id: string, range: CellRange, revealType: NotebookEditorRevealType): Promise<void> {
+        throw new Error('Method not implemented.');
+    }
+    $trySetSelections(id: string, range: CellRange[]): void {
+        throw new Error('Method not implemented.');
+    }
+
+    handleEditorsAdded(editors: readonly NotebookEditorWidget[]): void {
+        for (const editor of editors) {
+            this.mainThreadEditors.set(editor.id, editor);
+        }
+    }
+
+    handleEditorsRemoved(editorIds: readonly string[]): void {
+        for (const id of editorIds) {
+            this.mainThreadEditors.get(id)?.dispose();
+            this.mainThreadEditors.delete(id);
+        }
+    }
+
+    dispose(): void {
+    }
+}