@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocuments.js

@@ -0,0 +1,123 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { BoundModelReferenceCollection } from './mainThreadDocuments.js';
+import { NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { NotebookDto } from './mainThreadNotebookDto.js';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
+    constructor(extHostContext, _notebookEditorModelResolverService, _uriIdentityService) {
+        this._notebookEditorModelResolverService = _notebookEditorModelResolverService;
+        this._uriIdentityService = _uriIdentityService;
+        this._disposables = ( new DisposableStore());
+        this._documentEventListenersMapping = ( new ResourceMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocuments));
+        this._modelReferenceCollection = ( new BoundModelReferenceCollection(this._uriIdentityService.extUri));
+        this._disposables.add(this._notebookEditorModelResolverService.onDidChangeDirty(model => this._proxy.$acceptDirtyStateChanged(model.resource, model.isDirty())));
+        this._disposables.add(this._notebookEditorModelResolverService.onDidSaveNotebook(e => this._proxy.$acceptModelSaved(e)));
+        this._disposables.add(_notebookEditorModelResolverService.onWillFailWithConflict(e => {
+            this._modelReferenceCollection.remove(e.resource);
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._modelReferenceCollection.dispose();
+        dispose(( this._documentEventListenersMapping.values()));
+    }
+    handleNotebooksAdded(notebooks) {
+        for (const textModel of notebooks) {
+            const disposableStore = ( new DisposableStore());
+            disposableStore.add(textModel.onDidChangeContent(event => {
+                const eventDto = {
+                    versionId: event.versionId,
+                    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(cell => NotebookDto.toNotebookCellDto(cell)))]))
+                            });
+                            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);
+                this._proxy.$acceptModelChanged(textModel.uri, ( new SerializableObjectWithBuffers(eventDto)), this._notebookEditorModelResolverService.isDirty(textModel.uri), hasDocumentMetadataChangeEvent ? textModel.metadata : undefined);
+            }));
+            this._documentEventListenersMapping.set(textModel.uri, disposableStore);
+        }
+    }
+    handleNotebooksRemoved(uris) {
+        for (const uri of uris) {
+            this._documentEventListenersMapping.get(uri)?.dispose();
+            this._documentEventListenersMapping.delete(uri);
+        }
+    }
+    async $tryCreateNotebook(options) {
+        const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
+        ref.object.notebook.onWillDispose(() => {
+            ref.dispose();
+        });
+        this._proxy.$acceptDirtyStateChanged(ref.object.resource, true);
+        if (options.content) {
+            const data = NotebookDto.fromNotebookDataDto(options.content);
+            ref.object.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
+        }
+        return ref.object.resource;
+    }
+    async $tryOpenNotebook(uriComponents) {
+        const uri = URI.revive(uriComponents);
+        const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
+        this._modelReferenceCollection.add(uri, ref);
+        return uri;
+    }
+    async $trySaveNotebook(uriComponents) {
+        const uri = URI.revive(uriComponents);
+        const ref = await this._notebookEditorModelResolverService.resolve(uri);
+        const saveResult = await ref.object.save();
+        ref.dispose();
+        return saveResult;
+    }
+};
+MainThreadNotebookDocuments = ( __decorate([
+    ( __param(1, INotebookEditorModelResolverService)),
+    ( __param(2, IUriIdentityService))
+], MainThreadNotebookDocuments));
+
+export { MainThreadNotebookDocuments };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.js

@@ -0,0 +1,188 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { diffSets, diffMaps } from 'monaco-editor/esm/vs/base/common/collections.js';
+import { DisposableStore, DisposableMap, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { MainThreadNotebookDocuments } from './mainThreadNotebookDocuments.js';
+import { NotebookDto } from './mainThreadNotebookDto.js';
+import { MainThreadNotebookEditors } from './mainThreadNotebookEditors.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { editorGroupToColumn } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+var MainThreadNotebooksAndEditors_1;
+class NotebookAndEditorState {
+    static delta(before, after) {
+        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)),
+            addedEditors: editorDelta.added,
+            removedEditors: ( editorDelta.removed.map(removed => removed.getId())),
+            newActiveEditor: newActiveEditor,
+            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0
+                ? undefined
+                : ( [...after.visibleEditors].map(editor => editor[0]))
+        };
+    }
+    constructor(documents, textEditors, activeEditor, visibleEditors) {
+        this.documents = documents;
+        this.textEditors = textEditors;
+        this.activeEditor = activeEditor;
+        this.visibleEditors = visibleEditors;
+    }
+}
+let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class MainThreadNotebooksAndEditors {
+    constructor(extHostContext, instantiationService, _notebookService, _notebookEditorService, _editorService, _editorGroupService, _logService) {
+        this._notebookService = _notebookService;
+        this._notebookEditorService = _notebookEditorService;
+        this._editorService = _editorService;
+        this._editorGroupService = _editorGroupService;
+        this._logService = _logService;
+        this._disposables = ( new DisposableStore());
+        this._editorListeners = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebook));
+        this._mainThreadNotebooks = instantiationService.createInstance(MainThreadNotebookDocuments, extHostContext);
+        this._mainThreadEditors = instantiationService.createInstance(MainThreadNotebookEditors, extHostContext);
+        extHostContext.set(MainContext.MainThreadNotebookDocuments, this._mainThreadNotebooks);
+        extHostContext.set(MainContext.MainThreadNotebookEditors, this._mainThreadEditors);
+        this._notebookService.onWillAddNotebookDocument(() => this._updateState(), this, this._disposables);
+        this._notebookService.onDidRemoveNotebookDocument(() => this._updateState(), this, this._disposables);
+        this._editorService.onDidActiveEditorChange(() => this._updateState(), this, this._disposables);
+        this._editorService.onDidVisibleEditorsChange(() => this._updateState(), this, this._disposables);
+        this._notebookEditorService.onDidAddNotebookEditor(this._handleEditorAdd, this, this._disposables);
+        this._notebookEditorService.onDidRemoveNotebookEditor(this._handleEditorRemove, this, this._disposables);
+        this._updateState();
+    }
+    dispose() {
+        this._mainThreadNotebooks.dispose();
+        this._mainThreadEditors.dispose();
+        this._disposables.dispose();
+        this._editorListeners.dispose();
+    }
+    _handleEditorAdd(editor) {
+        this._editorListeners.set(editor.getId(), combinedDisposable(editor.onDidChangeModel(() => this._updateState()), editor.onDidFocusWidget(() => this._updateState(editor))));
+        this._updateState();
+    }
+    _handleEditorRemove(editor) {
+        this._editorListeners.deleteAndDispose(editor.getId());
+        this._updateState();
+    }
+    _updateState(focusedEditor) {
+        const editors = ( new Map());
+        const visibleEditorsMap = ( new Map());
+        for (const editor of this._notebookEditorService.listNotebookEditors()) {
+            if (editor.hasModel()) {
+                editors.set(editor.getId(), editor);
+            }
+        }
+        const activeNotebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        let activeEditor = null;
+        if (activeNotebookEditor) {
+            activeEditor = activeNotebookEditor.getId();
+        }
+        else if (focusedEditor?.textModel) {
+            activeEditor = focusedEditor.getId();
+        }
+        if (activeEditor && !( editors.has(activeEditor))) {
+            this._logService.trace('MainThreadNotebooksAndEditors#_updateState: active editor is not in editors list', activeEditor, ( editors.keys()));
+            activeEditor = null;
+        }
+        for (const editorPane of this._editorService.visibleEditorPanes) {
+            const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
+            if (notebookEditor?.hasModel() && ( editors.has(notebookEditor.getId()))) {
+                visibleEditorsMap.set(notebookEditor.getId(), notebookEditor);
+            }
+        }
+        const newState = ( new NotebookAndEditorState(( new Set(this._notebookService.listNotebookDocuments())), editors, activeEditor, visibleEditorsMap));
+        this._onDelta(NotebookAndEditorState.delta(this._currentState, newState));
+        this._currentState = newState;
+    }
+    _onDelta(delta) {
+        if (MainThreadNotebooksAndEditors_1._isDeltaEmpty(delta)) {
+            return;
+        }
+        const dto = {
+            removedDocuments: delta.removedDocuments,
+            removedEditors: delta.removedEditors,
+            newActiveEditor: delta.newActiveEditor,
+            visibleEditors: delta.visibleEditors,
+            addedDocuments: ( delta.addedDocuments.map(MainThreadNotebooksAndEditors_1._asModelAddData)),
+            addedEditors: ( delta.addedEditors.map(this._asEditorAddData, this)),
+        };
+        this._proxy.$acceptDocumentAndEditorsDelta(( new SerializableObjectWithBuffers(dto)));
+        this._mainThreadEditors.handleEditorsRemoved(delta.removedEditors);
+        this._mainThreadNotebooks.handleNotebooksRemoved(delta.removedDocuments);
+        this._mainThreadNotebooks.handleNotebooksAdded(delta.addedDocuments);
+        this._mainThreadEditors.handleEditorsAdded(delta.addedEditors);
+    }
+    static _isDeltaEmpty(delta) {
+        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;
+    }
+    static _asModelAddData(e) {
+        return {
+            viewType: e.viewType,
+            uri: e.uri,
+            metadata: e.metadata,
+            versionId: e.versionId,
+            cells: ( e.cells.map(NotebookDto.toNotebookCellDto))
+        };
+    }
+    _asEditorAddData(add) {
+        const pane = this._editorService.visibleEditorPanes.find(pane => getNotebookEditorFromEditorPane(pane) === add);
+        return {
+            id: add.getId(),
+            documentUri: add.textModel.uri,
+            selections: add.getSelections(),
+            visibleRanges: add.visibleRanges,
+            viewColumn: pane && editorGroupToColumn(this._editorGroupService, pane.group)
+        };
+    }
+};
+MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService)),
+    ( __param(2, INotebookService)),
+    ( __param(3, INotebookEditorService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, ILogService))
+], MainThreadNotebooksAndEditors);
+
+export { MainThreadNotebooksAndEditors };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDto.js

@@ -0,0 +1,129 @@
+import { CellExecutionUpdateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
+
+var NotebookDto;
+( (function(NotebookDto) {
+    function toNotebookOutputItemDto(item) {
+        return {
+            mime: item.mime,
+            valueBytes: item.data
+        };
+    }
+    NotebookDto.toNotebookOutputItemDto = toNotebookOutputItemDto;
+    function toNotebookOutputDto(output) {
+        return {
+            outputId: output.outputId,
+            metadata: output.metadata,
+            items: ( output.outputs.map(toNotebookOutputItemDto))
+        };
+    }
+    NotebookDto.toNotebookOutputDto = toNotebookOutputDto;
+    function toNotebookCellDataDto(cell) {
+        return {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            mime: cell.mime,
+            source: cell.source,
+            internalMetadata: cell.internalMetadata,
+            metadata: cell.metadata,
+            outputs: ( cell.outputs.map(toNotebookOutputDto))
+        };
+    }
+    NotebookDto.toNotebookCellDataDto = toNotebookCellDataDto;
+    function toNotebookDataDto(data) {
+        return {
+            metadata: data.metadata,
+            cells: ( data.cells.map(toNotebookCellDataDto))
+        };
+    }
+    NotebookDto.toNotebookDataDto = toNotebookDataDto;
+    function fromNotebookOutputItemDto(item) {
+        return {
+            mime: item.mime,
+            data: item.valueBytes
+        };
+    }
+    NotebookDto.fromNotebookOutputItemDto = fromNotebookOutputItemDto;
+    function fromNotebookOutputDto(output) {
+        return {
+            outputId: output.outputId,
+            metadata: output.metadata,
+            outputs: ( output.items.map(fromNotebookOutputItemDto))
+        };
+    }
+    NotebookDto.fromNotebookOutputDto = fromNotebookOutputDto;
+    function fromNotebookCellDataDto(cell) {
+        return {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            mime: cell.mime,
+            source: cell.source,
+            outputs: ( cell.outputs.map(fromNotebookOutputDto)),
+            metadata: cell.metadata,
+            internalMetadata: cell.internalMetadata
+        };
+    }
+    NotebookDto.fromNotebookCellDataDto = fromNotebookCellDataDto;
+    function fromNotebookDataDto(data) {
+        return {
+            metadata: data.metadata,
+            cells: ( data.cells.map(fromNotebookCellDataDto))
+        };
+    }
+    NotebookDto.fromNotebookDataDto = fromNotebookDataDto;
+    function toNotebookCellDto(cell) {
+        return {
+            handle: cell.handle,
+            uri: cell.uri,
+            source: cell.textBuffer.getLinesContent(),
+            eol: cell.textBuffer.getEOL(),
+            language: cell.language,
+            cellKind: cell.cellKind,
+            outputs: ( cell.outputs.map(toNotebookOutputDto)),
+            metadata: cell.metadata,
+            internalMetadata: cell.internalMetadata,
+        };
+    }
+    NotebookDto.toNotebookCellDto = toNotebookCellDto;
+    function fromCellExecuteUpdateDto(data) {
+        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;
+        }
+    }
+    NotebookDto.fromCellExecuteUpdateDto = fromCellExecuteUpdateDto;
+    function fromCellExecuteCompleteDto(data) {
+        return data;
+    }
+    NotebookDto.fromCellExecuteCompleteDto = fromCellExecuteCompleteDto;
+    function fromCellEditOperationDto(edit) {
+        if (edit.editType === 1 ) {
+            return {
+                editType: edit.editType,
+                index: edit.index,
+                count: edit.count,
+                cells: ( edit.cells.map(fromNotebookCellDataDto))
+            };
+        }
+        else {
+            return edit;
+        }
+    }
+    NotebookDto.fromCellEditOperationDto = fromCellEditOperationDto;
+})(NotebookDto || (NotebookDto = {})));
+
+export { NotebookDto };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookEditors.js

@@ -0,0 +1,131 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { editorGroupToColumn, columnToEditorGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ExtHostContext, NotebookEditorRevealType } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+
+class MainThreadNotebook {
+    constructor(editor, disposables) {
+        this.editor = editor;
+        this.disposables = disposables;
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+let MainThreadNotebookEditors = class MainThreadNotebookEditors {
+    constructor(extHostContext, _editorService, _notebookEditorService, _editorGroupService, _configurationService) {
+        this._editorService = _editorService;
+        this._notebookEditorService = _notebookEditorService;
+        this._editorGroupService = _editorGroupService;
+        this._configurationService = _configurationService;
+        this._disposables = ( new DisposableStore());
+        this._mainThreadEditors = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookEditors));
+        this._editorService.onDidActiveEditorChange(() => this._updateEditorViewColumns(), this, this._disposables);
+        this._editorGroupService.onDidRemoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
+        this._editorGroupService.onDidMoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+        dispose(( this._mainThreadEditors.values()));
+    }
+    handleEditorsAdded(editors) {
+        for (const editor of editors) {
+            const editorDisposables = ( new DisposableStore());
+            editorDisposables.add(editor.onDidChangeVisibleRanges(() => {
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges } });
+            }));
+            editorDisposables.add(editor.onDidChangeSelection(() => {
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { selections: { selections: editor.getSelections() } });
+            }));
+            const wrapper = ( new MainThreadNotebook(editor, editorDisposables));
+            this._mainThreadEditors.set(editor.getId(), wrapper);
+        }
+    }
+    handleEditorsRemoved(editorIds) {
+        for (const id of editorIds) {
+            this._mainThreadEditors.get(id)?.dispose();
+            this._mainThreadEditors.delete(id);
+        }
+    }
+    _updateEditorViewColumns() {
+        const result = Object.create(null);
+        for (const editorPane of this._editorService.visibleEditorPanes) {
+            const candidate = getNotebookEditorFromEditorPane(editorPane);
+            if (candidate && ( this._mainThreadEditors.has(candidate.getId()))) {
+                result[candidate.getId()] = editorGroupToColumn(this._editorGroupService, editorPane.group);
+            }
+        }
+        if (!equals(result, this._currentViewColumnInfo)) {
+            this._currentViewColumnInfo = result;
+            this._proxy.$acceptEditorViewColumns(result);
+        }
+    }
+    async $tryShowNotebookDocument(resource, viewType, options) {
+        const editorOptions = {
+            cellSelections: options.selections,
+            preserveFocus: options.preserveFocus,
+            pinned: options.pinned,
+            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
+            override: viewType
+        };
+        const editorPane = await this._editorService.openEditor({ resource: URI.revive(resource), options: editorOptions }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
+        const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
+        if (notebookEditor) {
+            return notebookEditor.getId();
+        }
+        else {
+            throw new Error(`Notebook Editor creation failure for document ${JSON.stringify(resource)}`);
+        }
+    }
+    async $tryRevealRange(id, range, revealType) {
+        const editor = this._notebookEditorService.getNotebookEditor(id);
+        if (!editor) {
+            return;
+        }
+        const notebookEditor = editor;
+        if (!notebookEditor.hasModel()) {
+            return;
+        }
+        if (range.start >= notebookEditor.getLength()) {
+            return;
+        }
+        const cell = notebookEditor.cellAt(range.start);
+        switch (revealType) {
+            case NotebookEditorRevealType.Default:
+                return notebookEditor.revealCellRangeInView(range);
+            case NotebookEditorRevealType.InCenter:
+                return notebookEditor.revealInCenter(cell);
+            case NotebookEditorRevealType.InCenterIfOutsideViewport:
+                return notebookEditor.revealInCenterIfOutsideViewport(cell);
+            case NotebookEditorRevealType.AtTop:
+                return notebookEditor.revealInViewAtTop(cell);
+        }
+    }
+    $trySetSelections(id, ranges) {
+        const editor = this._notebookEditorService.getNotebookEditor(id);
+        if (!editor) {
+            return;
+        }
+        editor.setSelections(ranges);
+        if (ranges.length) {
+            editor.setFocus({ start: ranges[0].start, end: ranges[0].start + 1 });
+        }
+    }
+};
+MainThreadNotebookEditors = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, INotebookEditorService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IConfigurationService))
+], MainThreadNotebookEditors));
+
+export { MainThreadNotebookEditors };