@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,119 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class CellContentPart extends Disposable {
+    constructor() {
+        super();
+        this.cellDisposables = ( new DisposableStore());
+    }
+    prepareRenderCell(element) { }
+    renderCell(element) {
+        this.currentCell = element;
+        this.didRenderCell(element);
+    }
+    didRenderCell(element) { }
+    unrenderCell(element) {
+        this.currentCell = undefined;
+        this.cellDisposables.clear();
+    }
+    prepareLayout() { }
+    updateInternalLayoutNow(element) { }
+    updateState(element, e) { }
+    updateForExecutionState(element, e) { }
+}
+class CellOverlayPart extends Disposable {
+    constructor() {
+        super();
+        this.cellDisposables = this._register(( new DisposableStore()));
+    }
+    prepareRenderCell(element) { }
+    renderCell(element) {
+        this.currentCell = element;
+        this.didRenderCell(element);
+    }
+    didRenderCell(element) { }
+    unrenderCell(element) {
+        this.currentCell = undefined;
+        this.cellDisposables.clear();
+    }
+    updateInternalLayoutNow(element) { }
+    updateState(element, e) { }
+    updateForExecutionState(element, e) { }
+}
+class CellPartsCollection extends Disposable {
+    constructor(targetWindow, contentParts, overlayParts) {
+        super();
+        this.targetWindow = targetWindow;
+        this.contentParts = contentParts;
+        this.overlayParts = overlayParts;
+        this._scheduledOverlayRendering = this._register(( new MutableDisposable()));
+        this._scheduledOverlayUpdateState = this._register(( new MutableDisposable()));
+        this._scheduledOverlayUpdateExecutionState = this._register(( new MutableDisposable()));
+    }
+    concatContentPart(other, targetWindow) {
+        return ( new CellPartsCollection(targetWindow, this.contentParts.concat(other), this.overlayParts));
+    }
+    concatOverlayPart(other, targetWindow) {
+        return ( new CellPartsCollection(targetWindow, this.contentParts, this.overlayParts.concat(other)));
+    }
+    scheduleRenderCell(element) {
+        for (const part of this.contentParts) {
+            part.prepareRenderCell(element);
+        }
+        for (const part of this.overlayParts) {
+            part.prepareRenderCell(element);
+        }
+        for (const part of this.contentParts) {
+            part.renderCell(element);
+        }
+        this._scheduledOverlayRendering.value = dom.modify(this.targetWindow, () => {
+            for (const part of this.overlayParts) {
+                part.renderCell(element);
+            }
+        });
+    }
+    unrenderCell(element) {
+        for (const part of this.contentParts) {
+            part.unrenderCell(element);
+        }
+        this._scheduledOverlayRendering.value = undefined;
+        this._scheduledOverlayUpdateState.value = undefined;
+        this._scheduledOverlayUpdateExecutionState.value = undefined;
+        for (const part of this.overlayParts) {
+            part.unrenderCell(element);
+        }
+    }
+    updateInternalLayoutNow(viewCell) {
+        for (const part of this.contentParts) {
+            part.updateInternalLayoutNow(viewCell);
+        }
+        for (const part of this.overlayParts) {
+            part.updateInternalLayoutNow(viewCell);
+        }
+    }
+    prepareLayout() {
+        for (const part of this.contentParts) {
+            part.prepareLayout();
+        }
+    }
+    updateState(viewCell, e) {
+        for (const part of this.contentParts) {
+            part.updateState(viewCell, e);
+        }
+        this._scheduledOverlayUpdateState.value = dom.modify(this.targetWindow, () => {
+            for (const part of this.overlayParts) {
+                part.updateState(viewCell, e);
+            }
+        });
+    }
+    updateForExecutionState(viewCell, e) {
+        for (const part of this.contentParts) {
+            part.updateForExecutionState(viewCell, e);
+        }
+        this._scheduledOverlayUpdateExecutionState.value = dom.modify(this.targetWindow, () => {
+            for (const part of this.overlayParts) {
+                part.updateForExecutionState(viewCell, e);
+            }
+        });
+    }
+}
+export { CellContentPart, CellOverlayPart, CellPartsCollection };

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

@@ -0,0 +1,27 @@
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+class CodiconActionViewItem extends MenuEntryActionViewItem {
+    updateLabel() {
+        if (this.options.label && this.label) {
+            dom.reset(this.label, ...renderLabelWithIcons(this._commandAction.label ?? ''));
+        }
+    }
+}
+class ActionViewWithLabel extends MenuEntryActionViewItem {
+    render(container) {
+        super.render(container);
+        container.classList.add('notebook-action-view-item');
+        this._actionLabel = document.createElement('a');
+        container.appendChild(this._actionLabel);
+        this.updateLabel();
+    }
+    updateLabel() {
+        if (this._actionLabel) {
+            this._actionLabel.classList.add('notebook-label');
+            this._actionLabel.innerText = this._action.label;
+            this._actionLabel.title = this._action.tooltip.length ? this._action.tooltip : this._action.label;
+        }
+    }
+}
+export { ActionViewWithLabel, CodiconActionViewItem };

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

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ICommentService } from '../../../../comments/browser/commentService.js';
+import { CommentThreadWidget } from '../../../../comments/browser/commentThreadWidget.js';
+import { CellContentPart } from '../cellPart.js';
+import { CellKind } from '../../../common/notebookCommon.js';
+let CellComments = class CellComments extends CellContentPart {
+    constructor(notebookEditor, container, contextKeyService, themeService, commentService, configurationService, instantiationService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.container = container;
+        this.contextKeyService = contextKeyService;
+        this.themeService = themeService;
+        this.commentService = commentService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this._initialized = false;
+        this._commentThreadWidget = null;
+        this.commentTheadDisposables = this._register(( new DisposableStore()));
+        this.container.classList.add('review-widget');
+        this._register(this.themeService.onDidColorThemeChange(this._applyTheme, this));
+        this._applyTheme();
+    }
+    async initialize(element) {
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        const info = await this._getCommentThreadForCell(element);
+        if (info) {
+            this._createCommentTheadWidget(info.owner, info.thread);
+        }
+    }
+    _createCommentTheadWidget(owner, commentThread) {
+        this._commentThreadWidget?.dispose();
+        this.commentTheadDisposables.clear();
+        this._commentThreadWidget = this.instantiationService.createInstance(CommentThreadWidget, this.container, this.notebookEditor, owner, this.notebookEditor.textModel.uri, this.contextKeyService, this.instantiationService, commentThread, undefined, undefined, {
+            codeBlockFontFamily: this.configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily
+        }, undefined, {
+            actionRunner: () => {
+            },
+            collapse: () => { }
+        });
+        const layoutInfo = this.notebookEditor.getLayoutInfo();
+        this._commentThreadWidget.display(layoutInfo.fontInfo.lineHeight);
+        this._applyTheme();
+        this.commentTheadDisposables.add(this._commentThreadWidget.onDidResize(() => {
+            if (this.currentElement?.cellKind === CellKind.Code && this._commentThreadWidget) {
+                this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height);
+            }
+        }));
+    }
+    _bindListeners() {
+        this.cellDisposables.add(this.commentService.onDidUpdateCommentThreads(async () => {
+            if (this.currentElement) {
+                const info = await this._getCommentThreadForCell(this.currentElement);
+                if (!this._commentThreadWidget && info) {
+                    this._createCommentTheadWidget(info.owner, info.thread);
+                    const layoutInfo = this.currentElement.layoutInfo;
+                    this.container.style.top = `${layoutInfo.outputContainerOffset + layoutInfo.outputTotalHeight}px`;
+                    this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height);
+                    return;
+                }
+                if (this._commentThreadWidget) {
+                    if (!info) {
+                        this._commentThreadWidget.dispose();
+                        this.currentElement.commentHeight = 0;
+                        return;
+                    }
+                    if (this._commentThreadWidget.commentThread === info.thread) {
+                        this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height);
+                        return;
+                    }
+                    this._commentThreadWidget.updateCommentThread(info.thread);
+                    this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height);
+                }
+            }
+        }));
+    }
+    _calculateCommentThreadHeight(bodyHeight) {
+        const layoutInfo = this.notebookEditor.getLayoutInfo();
+        const headHeight = Math.ceil(layoutInfo.fontInfo.lineHeight * 1.2);
+        const lineHeight = layoutInfo.fontInfo.lineHeight;
+        const arrowHeight = Math.round(lineHeight / 3);
+        const frameThickness = Math.round(lineHeight / 9) * 2;
+        const computedHeight = headHeight + bodyHeight + arrowHeight + frameThickness + 8 ;
+        return computedHeight;
+    }
+    async _getCommentThreadForCell(element) {
+        if (this.notebookEditor.hasModel()) {
+            const commentInfos = coalesce(await this.commentService.getNotebookComments(element.uri));
+            if (commentInfos.length && commentInfos[0].threads.length) {
+                return { owner: commentInfos[0].owner, thread: commentInfos[0].threads[0] };
+            }
+        }
+        return null;
+    }
+    _applyTheme() {
+        const theme = this.themeService.getColorTheme();
+        const fontInfo = this.notebookEditor.getLayoutInfo().fontInfo;
+        this._commentThreadWidget?.applyTheme(theme, fontInfo);
+    }
+    didRenderCell(element) {
+        if (element.cellKind === CellKind.Code) {
+            this.currentElement = element;
+            this.initialize(element);
+            this._bindListeners();
+        }
+    }
+    prepareLayout() {
+        if (this.currentElement?.cellKind === CellKind.Code && this._commentThreadWidget) {
+            this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height);
+        }
+    }
+    updateInternalLayoutNow(element) {
+        if (this.currentElement?.cellKind === CellKind.Code && this._commentThreadWidget) {
+            const layoutInfo = element.layoutInfo;
+            this.container.style.top = `${layoutInfo.outputContainerOffset + layoutInfo.outputTotalHeight}px`;
+        }
+    }
+};
+CellComments = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IThemeService)),
+    ( __param(4, ICommentService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IInstantiationService))
+], CellComments));
+export { CellComments };

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

@@ -0,0 +1,178 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CellFocusMode, CellEditState } from '../../notebookBrowser.js';
+import { CellContentPart } from '../cellPart.js';
+import { CodeCellViewModel } from '../../viewModel/codeCellViewModel.js';
+import { MarkupCellViewModel } from '../../viewModel/markupCellViewModel.js';
+import { NotebookCellExecutionState } from '../../../common/notebookCommon.js';
+import { NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_EDITOR_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_EXECUTION_STATE, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_INPUT_COLLAPSED, NOTEBOOK_CELL_OUTPUT_COLLAPSED, NOTEBOOK_CELL_LINE_NUMBERS, NOTEBOOK_CELL_RESOURCE } from '../../../common/notebookContextKeys.js';
+import { NotebookExecutionType, INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+let CellContextKeyPart = class CellContextKeyPart extends CellContentPart {
+    constructor(notebookEditor, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.cellContextKeyManager = this._register(this.instantiationService.createInstance(CellContextKeyManager, notebookEditor, undefined));
+    }
+    didRenderCell(element) {
+        this.cellContextKeyManager.updateForElement(element);
+    }
+};
+CellContextKeyPart = ( __decorate([
+    ( __param(1, IInstantiationService))
+], CellContextKeyPart));
+let CellContextKeyManager = class CellContextKeyManager extends Disposable {
+    constructor(notebookEditor, element, _contextKeyService, _notebookExecutionStateService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.element = element;
+        this._contextKeyService = _contextKeyService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this.elementDisposables = this._register(( new DisposableStore()));
+        this._contextKeyService.bufferChangeEvents(() => {
+            this.cellType = NOTEBOOK_CELL_TYPE.bindTo(this._contextKeyService);
+            this.cellEditable = NOTEBOOK_CELL_EDITABLE.bindTo(this._contextKeyService);
+            this.cellFocused = NOTEBOOK_CELL_FOCUSED.bindTo(this._contextKeyService);
+            this.cellEditorFocused = NOTEBOOK_CELL_EDITOR_FOCUSED.bindTo(this._contextKeyService);
+            this.markdownEditMode = NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.bindTo(this._contextKeyService);
+            this.cellRunState = NOTEBOOK_CELL_EXECUTION_STATE.bindTo(this._contextKeyService);
+            this.cellExecuting = NOTEBOOK_CELL_EXECUTING.bindTo(this._contextKeyService);
+            this.cellHasOutputs = NOTEBOOK_CELL_HAS_OUTPUTS.bindTo(this._contextKeyService);
+            this.cellContentCollapsed = NOTEBOOK_CELL_INPUT_COLLAPSED.bindTo(this._contextKeyService);
+            this.cellOutputCollapsed = NOTEBOOK_CELL_OUTPUT_COLLAPSED.bindTo(this._contextKeyService);
+            this.cellLineNumbers = NOTEBOOK_CELL_LINE_NUMBERS.bindTo(this._contextKeyService);
+            this.cellResource = NOTEBOOK_CELL_RESOURCE.bindTo(this._contextKeyService);
+            if (element) {
+                this.updateForElement(element);
+            }
+        });
+        this._register(this._notebookExecutionStateService.onDidChangeExecution(e => {
+            if (e.type === NotebookExecutionType.cell && this.element && e.affectsCell(this.element.uri)) {
+                this.updateForExecutionState();
+            }
+        }));
+    }
+    updateForElement(element) {
+        this.elementDisposables.clear();
+        this.element = element;
+        if (!element) {
+            return;
+        }
+        this.elementDisposables.add(element.onDidChangeState(e => this.onDidChangeState(e)));
+        if (element instanceof CodeCellViewModel) {
+            this.elementDisposables.add(element.onDidChangeOutputs(() => this.updateForOutputs()));
+        }
+        this.elementDisposables.add(this.notebookEditor.onDidChangeActiveCell(() => this.updateForFocusState()));
+        if (this.element instanceof MarkupCellViewModel) {
+            this.cellType.set('markup');
+        }
+        else if (this.element instanceof CodeCellViewModel) {
+            this.cellType.set('code');
+        }
+        this._contextKeyService.bufferChangeEvents(() => {
+            this.updateForFocusState();
+            this.updateForExecutionState();
+            this.updateForEditState();
+            this.updateForCollapseState();
+            this.updateForOutputs();
+            this.cellLineNumbers.set(this.element.lineNumbers);
+            this.cellResource.set(( this.element.uri.toString()));
+        });
+    }
+    onDidChangeState(e) {
+        this._contextKeyService.bufferChangeEvents(() => {
+            if (e.internalMetadataChanged) {
+                this.updateForExecutionState();
+            }
+            if (e.editStateChanged) {
+                this.updateForEditState();
+            }
+            if (e.focusModeChanged) {
+                this.updateForFocusState();
+            }
+            if (e.cellLineNumberChanged) {
+                this.cellLineNumbers.set(this.element.lineNumbers);
+            }
+            if (e.inputCollapsedChanged || e.outputCollapsedChanged) {
+                this.updateForCollapseState();
+            }
+        });
+    }
+    updateForFocusState() {
+        if (!this.element) {
+            return;
+        }
+        const activeCell = this.notebookEditor.getActiveCell();
+        this.cellFocused.set(this.notebookEditor.getActiveCell() === this.element);
+        if (activeCell === this.element) {
+            this.cellEditorFocused.set(this.element.focusMode === CellFocusMode.Editor);
+        }
+        else {
+            this.cellEditorFocused.set(false);
+        }
+    }
+    updateForExecutionState() {
+        if (!this.element) {
+            return;
+        }
+        const internalMetadata = this.element.internalMetadata;
+        this.cellEditable.set(!this.notebookEditor.isReadOnly);
+        const exeState = this._notebookExecutionStateService.getCellExecution(this.element.uri);
+        if (this.element instanceof MarkupCellViewModel) {
+            this.cellRunState.reset();
+            this.cellExecuting.reset();
+        }
+        else if (exeState?.state === NotebookCellExecutionState.Executing) {
+            this.cellRunState.set('executing');
+            this.cellExecuting.set(true);
+        }
+        else if (exeState?.state === NotebookCellExecutionState.Pending || exeState?.state === NotebookCellExecutionState.Unconfirmed) {
+            this.cellRunState.set('pending');
+            this.cellExecuting.set(true);
+        }
+        else if (internalMetadata.lastRunSuccess === true) {
+            this.cellRunState.set('succeeded');
+            this.cellExecuting.set(false);
+        }
+        else if (internalMetadata.lastRunSuccess === false) {
+            this.cellRunState.set('failed');
+            this.cellExecuting.set(false);
+        }
+        else {
+            this.cellRunState.set('idle');
+            this.cellExecuting.set(false);
+        }
+    }
+    updateForEditState() {
+        if (!this.element) {
+            return;
+        }
+        if (this.element instanceof MarkupCellViewModel) {
+            this.markdownEditMode.set(this.element.getEditState() === CellEditState.Editing);
+        }
+        else {
+            this.markdownEditMode.set(false);
+        }
+    }
+    updateForCollapseState() {
+        if (!this.element) {
+            return;
+        }
+        this.cellContentCollapsed.set(!!this.element.isInputCollapsed);
+        this.cellOutputCollapsed.set(!!this.element.isOutputCollapsed);
+    }
+    updateForOutputs() {
+        if (this.element instanceof CodeCellViewModel) {
+            this.cellHasOutputs.set(this.element.outputsViewModels.length > 0);
+        }
+        else {
+            this.cellHasOutputs.set(false);
+        }
+    }
+};
+CellContextKeyManager = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, INotebookExecutionStateService))
+], CellContextKeyManager));
+export { CellContextKeyManager, CellContextKeyPart };

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

@@ -0,0 +1,35 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CellContentPart } from '../cellPart.js';
+class CellDecorations extends CellContentPart {
+    constructor(rootContainer, decorationContainer) {
+        super();
+        this.rootContainer = rootContainer;
+        this.decorationContainer = decorationContainer;
+    }
+    didRenderCell(element) {
+        const removedClassNames = [];
+        this.rootContainer.classList.forEach(className => {
+            if (/^nb\-.*$/.test(className)) {
+                removedClassNames.push(className);
+            }
+        });
+        removedClassNames.forEach(className => {
+            this.rootContainer.classList.remove(className);
+        });
+        this.decorationContainer.innerText = '';
+        const generateCellTopDecorations = () => {
+            this.decorationContainer.innerText = '';
+            element.getCellDecorations().filter(options => options.topClassName !== undefined).forEach(options => {
+                this.decorationContainer.append(dom.$(`.${options.topClassName}`));
+            });
+        };
+        this.cellDisposables.add(element.onCellDecorationsChanged((e) => {
+            const modified = e.added.find(e => e.topClassName) || e.removed.find(e => e.topClassName);
+            if (modified) {
+                generateCellTopDecorations();
+            }
+        }));
+        generateCellTopDecorations();
+    }
+}
+export { CellDecorations };