@codingame/monaco-vscode-notebook-service-override 37.1.0 → 37.3.0

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

@@ -0,0 +1,194 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { diffSets, diffMaps } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
+import { DisposableStore, DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { MainThreadNotebookDocuments } from './mainThreadNotebookDocuments.js';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { MainThreadNotebookEditors } from './mainThreadNotebookEditors.js';
+import { extHostCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { editorGroupToColumn } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/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),
+            viewType: add.getViewModel().viewType
+        };
+    }
+};
+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/mainThreadNotebookEditors.d.ts

@@ -0,0 +1,27 @@
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { ICellRange } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookDocumentShowOptions, MainThreadNotebookEditorsShape, NotebookEditorRevealType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadNotebookEditors implements MainThreadNotebookEditorsShape {
+    private readonly _editorService;
+    private readonly _notebookEditorService;
+    private readonly _editorGroupService;
+    private readonly _configurationService;
+    private readonly _disposables;
+    private readonly _proxy;
+    private readonly _mainThreadEditors;
+    private _currentViewColumnInfo?;
+    constructor(extHostContext: IExtHostContext, _editorService: IEditorService, _notebookEditorService: INotebookEditorService, _editorGroupService: IEditorGroupsService, _configurationService: IConfigurationService);
+    dispose(): void;
+    handleEditorsAdded(editors: readonly INotebookEditor[]): void;
+    handleEditorsRemoved(editorIds: readonly string[]): void;
+    private _updateEditorViewColumns;
+    $tryShowNotebookDocument(resource: UriComponents, viewType: string, options: INotebookDocumentShowOptions): Promise<string>;
+    $tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType): Promise<void>;
+    $trySetSelections(id: string, ranges: ICellRange[]): void;
+}

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

@@ -0,0 +1,149 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ExtHostContext, NotebookEditorRevealType } from '@codingame/monaco-vscode-api/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,
+            label: options.label,
+            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 };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookKernels.d.ts

@@ -0,0 +1,49 @@
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { INotebookExecutionStateService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service";
+import { VariablesResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService";
+import { INotebookKernelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service";
+import { SerializableObjectWithBuffers } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { ICellExecuteUpdateDto, ICellExecutionCompleteDto, INotebookKernelDto2, MainThreadNotebookKernelsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+export declare class MainThreadNotebookKernels implements MainThreadNotebookKernelsShape {
+    private readonly _languageService;
+    private readonly _notebookKernelService;
+    private readonly _notebookExecutionStateService;
+    private readonly _notebookService;
+    private readonly _editors;
+    private readonly _disposables;
+    private readonly _kernels;
+    private readonly _kernelDetectionTasks;
+    private readonly _kernelSourceActionProviders;
+    private readonly _kernelSourceActionProvidersEventRegistrations;
+    private readonly _proxy;
+    private readonly _executions;
+    private readonly _notebookExecutions;
+    constructor(extHostContext: IExtHostContext, _languageService: ILanguageService, _notebookKernelService: INotebookKernelService, _notebookExecutionStateService: INotebookExecutionStateService, _notebookService: INotebookService, notebookEditorService: INotebookEditorService);
+    dispose(): void;
+    private _onEditorAdd;
+    private _onEditorRemove;
+    $postMessage(handle: number, editorId: string | undefined, message: unknown): Promise<boolean>;
+    private variableRequestIndex;
+    private variableRequestMap;
+    $receiveVariable(requestId: string, variable: VariablesResult): void;
+    $addKernel(handle: number, data: INotebookKernelDto2): Promise<void>;
+    $updateKernel(handle: number, data: Partial<INotebookKernelDto2>): void;
+    $removeKernel(handle: number): void;
+    $updateNotebookPriority(handle: number, notebook: UriComponents, value: number | undefined): void;
+    $createExecution(handle: number, controllerId: string, rawUri: UriComponents, cellHandle: number): void;
+    $updateExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecuteUpdateDto[]>): void;
+    $completeExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecutionCompleteDto>): void;
+    $createNotebookExecution(handle: number, controllerId: string, rawUri: UriComponents): void;
+    $beginNotebookExecution(handle: number): void;
+    $completeNotebookExecution(handle: number): void;
+    $addKernelDetectionTask(handle: number, notebookType: string): Promise<void>;
+    $removeKernelDetectionTask(handle: number): void;
+    $addKernelSourceActionProvider(handle: number, eventHandle: number, notebookType: string): Promise<void>;
+    $removeKernelSourceActionProvider(handle: number, eventHandle: number): void;
+    $emitNotebookKernelSourceActionsChangeEvent(eventHandle: number): void;
+    $variablesUpdated(notebookUri: UriComponents): void;
+}