@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellExecution.js

@@ -0,0 +1,71 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CellContentPart } from '../cellPart.js';
+import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+const UPDATE_EXECUTION_ORDER_GRACE_PERIOD = 200;
+let CellExecutionPart = class CellExecutionPart extends CellContentPart {
+    constructor(_notebookEditor, _executionOrderLabel, _notebookExecutionStateService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._executionOrderLabel = _executionOrderLabel;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this.kernelDisposables = this._register(( new DisposableStore()));
+        this._register(this._notebookEditor.onDidChangeActiveKernel(() => {
+            if (this.currentCell) {
+                this.kernelDisposables.clear();
+                if (this._notebookEditor.activeKernel) {
+                    this.kernelDisposables.add(this._notebookEditor.activeKernel.onDidChange(() => {
+                        if (this.currentCell) {
+                            this.updateExecutionOrder(this.currentCell.internalMetadata);
+                        }
+                    }));
+                }
+                this.updateExecutionOrder(this.currentCell.internalMetadata);
+            }
+        }));
+    }
+    didRenderCell(element) {
+        this.updateExecutionOrder(element.internalMetadata, true);
+    }
+    updateExecutionOrder(internalMetadata, forceClear = false) {
+        if (this._notebookEditor.activeKernel?.implementsExecutionOrder || (!this._notebookEditor.activeKernel && typeof internalMetadata.executionOrder === 'number')) {
+            if (typeof internalMetadata.executionOrder !== 'number' && !forceClear && !!this._notebookExecutionStateService.getCellExecution(this.currentCell.uri)) {
+                const renderingCell = this.currentCell;
+                disposableTimeout(() => {
+                    if (this.currentCell === renderingCell) {
+                        this.updateExecutionOrder(this.currentCell.internalMetadata, true);
+                    }
+                }, UPDATE_EXECUTION_ORDER_GRACE_PERIOD, this.cellDisposables);
+                return;
+            }
+            const executionOrderLabel = typeof internalMetadata.executionOrder === 'number' ?
+                `[${internalMetadata.executionOrder}]` :
+                '[ ]';
+            this._executionOrderLabel.innerText = executionOrderLabel;
+        }
+        else {
+            this._executionOrderLabel.innerText = '';
+        }
+    }
+    updateState(element, e) {
+        if (e.internalMetadataChanged) {
+            this.updateExecutionOrder(element.internalMetadata);
+        }
+    }
+    updateInternalLayoutNow(element) {
+        if (element.isInputCollapsed) {
+            dom.hide(this._executionOrderLabel);
+        }
+        else {
+            dom.show(this._executionOrderLabel);
+            const top = element.layoutInfo.editorHeight - 22 + element.layoutInfo.statusBarHeight;
+            this._executionOrderLabel.style.top = `${top}px`;
+        }
+    }
+};
+CellExecutionPart = ( __decorate([
+    ( __param(2, INotebookExecutionStateService))
+], CellExecutionPart));
+export { CellExecutionPart };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellFocus.js

@@ -0,0 +1,20 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CellContentPart } from '../cellPart.js';
+class CellFocusPart extends CellContentPart {
+    constructor(containerElement, focusSinkElement, notebookEditor) {
+        super();
+        this._register(dom.addDisposableListener(containerElement, dom.EventType.FOCUS, () => {
+            if (this.currentCell) {
+                notebookEditor.focusElement(this.currentCell);
+            }
+        }, true));
+        if (focusSinkElement) {
+            this._register(dom.addDisposableListener(focusSinkElement, dom.EventType.FOCUS, () => {
+                if (this.currentCell && this.currentCell.outputsViewModels.length) {
+                    notebookEditor.focusNotebookCell(this.currentCell, 'output');
+                }
+            }));
+        }
+    }
+}
+export { CellFocusPart };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellFocusIndicator.js

@@ -0,0 +1,85 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { FastDomNode } from 'monaco-editor/esm/vs/base/browser/fastDomNode.js';
+import { CellContentPart } from '../cellPart.js';
+import { CellKind } from '../../../common/notebookCommon.js';
+class CellFocusIndicator extends CellContentPart {
+    constructor(notebookEditor, titleToolbar, top, left, right, bottom) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.titleToolbar = titleToolbar;
+        this.top = top;
+        this.left = left;
+        this.right = right;
+        this.bottom = bottom;
+        this.codeFocusIndicator = ( new FastDomNode(
+            dom.append(this.left.domNode, dom.$('.codeOutput-focus-indicator-container', undefined, dom.$('.codeOutput-focus-indicator.code-focus-indicator')))
+        ));
+        this.outputFocusIndicator = ( new FastDomNode(
+            dom.append(this.left.domNode, dom.$('.codeOutput-focus-indicator-container', undefined, dom.$('.codeOutput-focus-indicator.output-focus-indicator')))
+        ));
+        this._register(dom.addDisposableListener(this.codeFocusIndicator.domNode, dom.EventType.CLICK, () => {
+            if (this.currentCell) {
+                this.currentCell.isInputCollapsed = !this.currentCell.isInputCollapsed;
+            }
+        }));
+        this._register(dom.addDisposableListener(this.outputFocusIndicator.domNode, dom.EventType.CLICK, () => {
+            if (this.currentCell) {
+                this.currentCell.isOutputCollapsed = !this.currentCell.isOutputCollapsed;
+            }
+        }));
+        this._register(dom.addDisposableListener(this.left.domNode, dom.EventType.DBLCLICK, e => {
+            if (!this.currentCell || !this.notebookEditor.hasModel()) {
+                return;
+            }
+            if (e.target !== this.left.domNode) {
+                return;
+            }
+            const clickedOnInput = e.offsetY < this.currentCell.layoutInfo.outputContainerOffset;
+            if (clickedOnInput) {
+                this.currentCell.isInputCollapsed = !this.currentCell.isInputCollapsed;
+            }
+            else {
+                this.currentCell.isOutputCollapsed = !this.currentCell.isOutputCollapsed;
+            }
+        }));
+        this._register(this.titleToolbar.onDidUpdateActions(() => {
+            this.updateFocusIndicatorsForTitleMenu();
+        }));
+    }
+    updateInternalLayoutNow(element) {
+        if (element.cellKind === CellKind.Markup) {
+            const indicatorPostion = this.notebookEditor.notebookOptions.computeIndicatorPosition(element.layoutInfo.totalHeight, element.layoutInfo.foldHintHeight, this.notebookEditor.textModel?.viewType);
+            this.bottom.domNode.style.transform = `translateY(${indicatorPostion.bottomIndicatorTop}px)`;
+            this.left.setHeight(indicatorPostion.verticalIndicatorHeight);
+            this.right.setHeight(indicatorPostion.verticalIndicatorHeight);
+            this.codeFocusIndicator.setHeight(indicatorPostion.verticalIndicatorHeight - this.getIndicatorTopMargin() * 2 - element.layoutInfo.chatHeight);
+        }
+        else {
+            const cell = element;
+            const layoutInfo = this.notebookEditor.notebookOptions.getLayoutConfiguration();
+            const bottomToolbarDimensions = this.notebookEditor.notebookOptions.computeBottomToolbarDimensions(this.notebookEditor.textModel?.viewType);
+            const indicatorHeight = cell.layoutInfo.codeIndicatorHeight + cell.layoutInfo.outputIndicatorHeight + cell.layoutInfo.commentHeight;
+            this.left.setHeight(indicatorHeight);
+            this.right.setHeight(indicatorHeight);
+            this.codeFocusIndicator.setHeight(cell.layoutInfo.codeIndicatorHeight);
+            this.outputFocusIndicator.setHeight(Math.max(cell.layoutInfo.outputIndicatorHeight - cell.viewContext.notebookOptions.getLayoutConfiguration().focusIndicatorGap, 0));
+            this.bottom.domNode.style.transform = `translateY(${cell.layoutInfo.totalHeight - bottomToolbarDimensions.bottomToolbarGap - layoutInfo.cellBottomMargin}px)`;
+        }
+        this.updateFocusIndicatorsForTitleMenu();
+    }
+    updateFocusIndicatorsForTitleMenu() {
+        const y = (this.currentCell?.layoutInfo.chatHeight ?? 0) + this.getIndicatorTopMargin();
+        this.left.domNode.style.transform = `translateY(${y}px)`;
+        this.right.domNode.style.transform = `translateY(${y}px)`;
+    }
+    getIndicatorTopMargin() {
+        const layoutInfo = this.notebookEditor.notebookOptions.getLayoutConfiguration();
+        if (this.titleToolbar.hasActions) {
+            return layoutInfo.editorToolbarHeight + layoutInfo.cellTopMargin;
+        }
+        else {
+            return layoutInfo.cellTopMargin;
+        }
+    }
+}
+export { CellFocusIndicator };