@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,190 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { ResourceMap } from '../../../../../base/common/map.js';
+import { getDefaultNotebookCreationOptions, NotebookEditorWidget } from '../notebookEditorWidget.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { NotebookEditorInput, isCompositeNotebookEditorInput } from '../../common/notebookEditorInput.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { InteractiveWindowOpen } from '../../common/notebookContextKeys.js';
+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

@@ -0,0 +1,104 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { toDisposable } from '../../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.js';
+import { ILogService } from '../../../../../platform/log/common/log.js';
+import { IWorkspaceTrustRequestService } from '../../../../../platform/workspace/common/workspaceTrust.js';
+import { KernelPickerMRUStrategy } from '../viewParts/notebookKernelQuickPickStrategy.js';
+import { CellKind, NotebookCellExecutionState } from '../../common/notebookCommon.js';
+import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.js';
+import { INotebookKernelService, INotebookKernelHistoryService } from '../../common/notebookKernelService.js';
+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 };