@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookEditorServiceImpl.js

@@ -1,192 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { getDefaultNotebookCreationOptions, NotebookEditorWidget } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { NotebookEditorInput, isCompositeNotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { InteractiveWindowOpen } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-
-let NotebookEditorWidgetService = class NotebookEditorWidgetService {
-    constructor(editorGroupService, editorService, contextKeyService) {
-        this.editorGroupService = editorGroupService;
-        this._tokenPool = 1;
-        this._disposables = ( new DisposableStore());
-        this._notebookEditors = ( new Map());
-        this._onNotebookEditorAdd = ( new Emitter());
-        this._onNotebookEditorsRemove = ( new Emitter());
-        this.onDidAddNotebookEditor = this._onNotebookEditorAdd.event;
-        this.onDidRemoveNotebookEditor = this._onNotebookEditorsRemove.event;
-        this._borrowableEditors = ( new Map());
-        const groupListener = ( new Map());
-        const onNewGroup = (group) => {
-            const { id } = group;
-            const listeners = [];
-            listeners.push(group.onDidCloseEditor(e => {
-                const widgets = this._borrowableEditors.get(group.id);
-                if (!widgets) {
-                    return;
-                }
-                const inputs = e.editor instanceof NotebookEditorInput ? [e.editor] : (isCompositeNotebookEditorInput(e.editor) ? e.editor.editorInputs : []);
-                inputs.forEach(input => {
-                    const value = widgets.get(input.resource);
-                    if (!value) {
-                        return;
-                    }
-                    value.token = undefined;
-                    this._disposeWidget(value.widget);
-                    widgets.delete(input.resource);
-                    value.widget = undefined;
-                });
-            }));
-            listeners.push(group.onWillMoveEditor(e => {
-                if (e.editor instanceof NotebookEditorInput) {
-                    this._allowWidgetMove(e.editor, e.groupId, e.target);
-                }
-                if (isCompositeNotebookEditorInput(e.editor)) {
-                    e.editor.editorInputs.forEach(input => {
-                        this._allowWidgetMove(input, e.groupId, e.target);
-                    });
-                }
-            }));
-            groupListener.set(id, listeners);
-        };
-        this._disposables.add(editorGroupService.onDidAddGroup(onNewGroup));
-        editorGroupService.whenReady.then(() => editorGroupService.groups.forEach(onNewGroup));
-        this._disposables.add(editorGroupService.onDidRemoveGroup(group => {
-            const listeners = groupListener.get(group.id);
-            if (listeners) {
-                listeners.forEach(listener => listener.dispose());
-                groupListener.delete(group.id);
-            }
-            const widgets = this._borrowableEditors.get(group.id);
-            this._borrowableEditors.delete(group.id);
-            if (widgets) {
-                for (const value of ( widgets.values())) {
-                    value.token = undefined;
-                    this._disposeWidget(value.widget);
-                }
-            }
-        }));
-        const interactiveWindowOpen = InteractiveWindowOpen.bindTo(contextKeyService);
-        this._disposables.add(editorService.onDidEditorsChange(e => {
-            if (e.event.kind === 4  && !interactiveWindowOpen.get()) {
-                if (editorService.editors.find(editor => editor.editorId === 'interactive')) {
-                    interactiveWindowOpen.set(true);
-                }
-            }
-            else if (e.event.kind === 5  && interactiveWindowOpen.get()) {
-                if (!editorService.editors.find(editor => editor.editorId === 'interactive')) {
-                    interactiveWindowOpen.set(false);
-                }
-            }
-        }));
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._onNotebookEditorAdd.dispose();
-        this._onNotebookEditorsRemove.dispose();
-    }
-    _disposeWidget(widget) {
-        widget.onWillHide();
-        const domNode = widget.getDomNode();
-        widget.dispose();
-        domNode.remove();
-    }
-    _allowWidgetMove(input, sourceID, targetID) {
-        const sourcePart = this.editorGroupService.getPart(sourceID);
-        const targetPart = this.editorGroupService.getPart(targetID);
-        if (sourcePart.windowId !== targetPart.windowId) {
-            return;
-        }
-        const targetWidget = this._borrowableEditors.get(targetID)?.get(input.resource);
-        if (targetWidget) {
-            return;
-        }
-        const widget = this._borrowableEditors.get(sourceID)?.get(input.resource);
-        if (!widget) {
-            throw new Error('no widget at source group');
-        }
-        this._borrowableEditors.get(sourceID)?.delete(input.resource);
-        let targetMap = this._borrowableEditors.get(targetID);
-        if (!targetMap) {
-            targetMap = ( new ResourceMap());
-            this._borrowableEditors.set(targetID, targetMap);
-        }
-        targetMap.set(input.resource, widget);
-    }
-    retrieveExistingWidgetFromURI(resource) {
-        for (const widgetInfo of ( this._borrowableEditors.values())) {
-            const widget = widgetInfo.get(resource);
-            if (widget) {
-                return this._createBorrowValue(widget.token, widget);
-            }
-        }
-        return undefined;
-    }
-    retrieveAllExistingWidgets() {
-        const ret = [];
-        for (const widgetInfo of ( this._borrowableEditors.values())) {
-            for (const widget of ( widgetInfo.values())) {
-                ret.push(this._createBorrowValue(widget.token, widget));
-            }
-        }
-        return ret;
-    }
-    retrieveWidget(accessor, group, input, creationOptions, initialDimension, codeWindow) {
-        let value = this._borrowableEditors.get(group.id)?.get(input.resource);
-        if (!value) {
-            const instantiationService = accessor.get(IInstantiationService);
-            const ctorOptions = creationOptions ?? getDefaultNotebookCreationOptions();
-            const widget = instantiationService.createInstance(NotebookEditorWidget, {
-                ...ctorOptions,
-                codeWindow: codeWindow ?? ctorOptions.codeWindow,
-            }, initialDimension);
-            const token = this._tokenPool++;
-            value = { widget, token };
-            let map = this._borrowableEditors.get(group.id);
-            if (!map) {
-                map = ( new ResourceMap());
-                this._borrowableEditors.set(group.id, map);
-            }
-            map.set(input.resource, value);
-        }
-        else {
-            value.token = this._tokenPool++;
-        }
-        return this._createBorrowValue(value.token, value);
-    }
-    _createBorrowValue(myToken, widget) {
-        return {
-            get value() {
-                return widget.token === myToken ? widget.widget : undefined;
-            }
-        };
-    }
-    addNotebookEditor(editor) {
-        this._notebookEditors.set(editor.getId(), editor);
-        this._onNotebookEditorAdd.fire(editor);
-    }
-    removeNotebookEditor(editor) {
-        if (( this._notebookEditors.has(editor.getId()))) {
-            this._notebookEditors.delete(editor.getId());
-            this._onNotebookEditorsRemove.fire(editor);
-        }
-    }
-    getNotebookEditor(editorId) {
-        return this._notebookEditors.get(editorId);
-    }
-    listNotebookEditors() {
-        return ( [...this._notebookEditors].map(e => e[1]));
-    }
-};
-NotebookEditorWidgetService = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IContextKeyService))
-], NotebookEditorWidgetService));
-
-export { NotebookEditorWidgetService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl.js

@@ -1,106 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { KernelPickerMRUStrategy } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelQuickPickStrategy';
-import { CellKind, NotebookCellExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { INotebookKernelService, INotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-
-let NotebookExecutionService = class NotebookExecutionService {
-    constructor(_commandService, _notebookKernelService, _notebookKernelHistoryService, _workspaceTrustRequestService, _logService, _notebookExecutionStateService) {
-        this._commandService = _commandService;
-        this._notebookKernelService = _notebookKernelService;
-        this._notebookKernelHistoryService = _notebookKernelHistoryService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._logService = _logService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this.cellExecutionParticipants = ( new Set());
-    }
-    async executeNotebookCells(notebook, cells, contextKeyService) {
-        const cellsArr = Array.from(cells)
-            .filter(c => c.cellKind === CellKind.Code);
-        if (!cellsArr.length) {
-            return;
-        }
-        this._logService.debug(`NotebookExecutionService#executeNotebookCells ${JSON.stringify(( cellsArr.map(c => c.handle)))}`);
-        const message = ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl',
-            'notebookRunTrust',
-            "Executing a notebook cell will run code from this workspace."
-        ));
-        const trust = await this._workspaceTrustRequestService.requestWorkspaceTrust({ message });
-        if (!trust) {
-            return;
-        }
-        const cellExecutions = [];
-        for (const cell of cellsArr) {
-            const cellExe = this._notebookExecutionStateService.getCellExecution(cell.uri);
-            if (!!cellExe) {
-                continue;
-            }
-            cellExecutions.push([cell, this._notebookExecutionStateService.createCellExecution(notebook.uri, cell.handle)]);
-        }
-        const kernel = await KernelPickerMRUStrategy.resolveKernel(notebook, this._notebookKernelService, this._notebookKernelHistoryService, this._commandService);
-        if (!kernel) {
-            cellExecutions.forEach(cellExe => cellExe[1].complete({}));
-            return;
-        }
-        this._notebookKernelHistoryService.addMostRecentKernel(kernel);
-        const validCellExecutions = [];
-        for (const [cell, cellExecution] of cellExecutions) {
-            if (!kernel.supportedLanguages.includes(cell.language)) {
-                cellExecution.complete({});
-            }
-            else {
-                validCellExecutions.push(cellExecution);
-            }
-        }
-        if (validCellExecutions.length > 0) {
-            await this.runExecutionParticipants(validCellExecutions);
-            this._notebookKernelService.selectKernelForNotebook(kernel, notebook);
-            await kernel.executeNotebookCellsRequest(notebook.uri, ( validCellExecutions.map(c => c.cellHandle)));
-            const unconfirmed = validCellExecutions.filter(exe => exe.state === NotebookCellExecutionState.Unconfirmed);
-            if (unconfirmed.length) {
-                this._logService.debug(`NotebookExecutionService#executeNotebookCells completing unconfirmed executions ${JSON.stringify(( unconfirmed.map(exe => exe.cellHandle)))}`);
-                unconfirmed.forEach(exe => exe.complete({}));
-            }
-        }
-    }
-    async cancelNotebookCellHandles(notebook, cells) {
-        const cellsArr = Array.from(cells);
-        this._logService.debug(`NotebookExecutionService#cancelNotebookCellHandles ${JSON.stringify(cellsArr)}`);
-        const kernel = this._notebookKernelService.getSelectedOrSuggestedKernel(notebook);
-        if (kernel) {
-            await kernel.cancelNotebookCellExecution(notebook.uri, cellsArr);
-        }
-    }
-    async cancelNotebookCells(notebook, cells) {
-        this.cancelNotebookCellHandles(notebook, Array.from(cells, cell => cell.handle));
-    }
-    registerExecutionParticipant(participant) {
-        this.cellExecutionParticipants.add(participant);
-        return toDisposable(() => this.cellExecutionParticipants.delete(participant));
-    }
-    async runExecutionParticipants(executions) {
-        for (const participant of this.cellExecutionParticipants) {
-            await participant.onWillExecuteCell(executions);
-        }
-        return;
-    }
-    dispose() {
-        this._activeProxyKernelExecutionToken?.dispose(true);
-    }
-};
-NotebookExecutionService = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, INotebookKernelService)),
-    ( __param(2, INotebookKernelHistoryService)),
-    ( __param(3, IWorkspaceTrustRequestService)),
-    ( __param(4, ILogService)),
-    ( __param(5, INotebookExecutionStateService))
-], NotebookExecutionService));
-
-export { NotebookExecutionService };