@codingame/monaco-vscode-notebook-service-override 5.2.0 → 6.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellCommands/cellCommands.js

@@ -0,0 +1,549 @@
+import { KeyMod, KeyCode, KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import { Mimes } from 'vscode/vscode/vs/base/common/mime';
+import { IBulkEditService, ResourceTextEdit } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { InputFocusedContext, InputFocusedContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
+import { KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ResourceNotebookCellEdit } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { moveCellRange, copyCellRange, computeCellLinesContents, joinCellsWithSurrounds, joinSelectedCells, changeCellToKind } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
+import { NotebookCellAction, CellOverflowToolbarGroups, CellToolbarOrder, CELL_TITLE_CELL_GROUP_ID, NotebookMultiCellAction, parseMultiCellExecutionArgs, cellExecutionArgs } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { CellFocusMode, EXPAND_CELL_INPUT_COMMAND_ID, EXPAND_CELL_OUTPUT_COMMAND_ID } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_CELL_INPUT_COLLAPSED, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_CELL_OUTPUT_COLLAPSED, NOTEBOOK_CELL_HAS_OUTPUTS } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { moveUpIcon, moveDownIcon, splitCellIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { CellEditType, CellKind, NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/cellCommands/cellCommands";
+const MOVE_CELL_UP_COMMAND_ID = 'notebook.cell.moveUp';
+const MOVE_CELL_DOWN_COMMAND_ID = 'notebook.cell.moveDown';
+const COPY_CELL_UP_COMMAND_ID = 'notebook.cell.copyUp';
+const COPY_CELL_DOWN_COMMAND_ID = 'notebook.cell.copyDown';
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: MOVE_CELL_UP_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 0, "Move Cell Up")),
+            icon: moveUpIcon,
+            keybinding: {
+                primary: KeyMod.Alt | KeyCode.UpArrow,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED,  (InputFocusedContext.toNegated())))),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.equals('config.notebook.dragAndDropEnabled', false))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 14
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        return moveCellRange(context, 'up');
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: MOVE_CELL_DOWN_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 1, "Move Cell Down")),
+            icon: moveDownIcon,
+            keybinding: {
+                primary: KeyMod.Alt | KeyCode.DownArrow,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED,  (InputFocusedContext.toNegated())))),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.equals('config.notebook.dragAndDropEnabled', false))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 14
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        return moveCellRange(context, 'down');
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: COPY_CELL_UP_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 2, "Copy Cell Up")),
+            keybinding: {
+                primary: KeyMod.Alt | KeyMod.Shift | KeyCode.UpArrow,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED,  (InputFocusedContext.toNegated())))),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        return copyCellRange(context, 'up');
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: COPY_CELL_DOWN_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 3, "Copy Cell Down")),
+            keybinding: {
+                primary: KeyMod.Alt | KeyMod.Shift | KeyCode.DownArrow,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED,  (InputFocusedContext.toNegated())))),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 13
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        return copyCellRange(context, 'down');
+    }
+});
+const SPLIT_CELL_COMMAND_ID = 'notebook.cell.split';
+const JOIN_SELECTED_CELLS_COMMAND_ID = 'notebook.cell.joinSelected';
+const JOIN_CELL_ABOVE_COMMAND_ID = 'notebook.cell.joinAbove';
+const JOIN_CELL_BELOW_COMMAND_ID = 'notebook.cell.joinBelow';
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: SPLIT_CELL_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 4, "Split Cell")),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_EDITABLE,
+                    NOTEBOOK_CELL_EDITABLE,
+                     (NOTEBOOK_CELL_INPUT_COLLAPSED.toNegated())
+                ))),
+                order: CellToolbarOrder.SplitCell,
+                group: CELL_TITLE_CELL_GROUP_ID
+            },
+            icon: splitCellIcon,
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_FOCUSED,
+                    NOTEBOOK_EDITOR_EDITABLE,
+                    NOTEBOOK_CELL_EDITABLE,
+                    EditorContextKeys.editorTextFocus
+                ))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backslash),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+        });
+    }
+    async runWithContext(accessor, context) {
+        if (context.notebookEditor.isReadOnly) {
+            return;
+        }
+        const bulkEditService = accessor.get(IBulkEditService);
+        const cell = context.cell;
+        const index = context.notebookEditor.getCellIndex(cell);
+        const splitPoints = cell.focusMode === CellFocusMode.Container ? [{ lineNumber: 1, column: 1 }] : cell.getSelectionsStartPosition();
+        if (splitPoints && splitPoints.length > 0) {
+            await cell.resolveTextModel();
+            if (!cell.hasModel()) {
+                return;
+            }
+            const newLinesContents = computeCellLinesContents(cell, splitPoints);
+            if (newLinesContents) {
+                const language = cell.language;
+                const kind = cell.cellKind;
+                const mime = cell.mime;
+                const textModel = await cell.resolveTextModel();
+                await bulkEditService.apply([
+                    ( (new ResourceTextEdit(
+                    cell.uri,
+                    { range: textModel.getFullModelRange(), text: newLinesContents[0] }
+                ))),
+                    ( (new ResourceNotebookCellEdit(context.notebookEditor.textModel.uri, {
+                        editType: CellEditType.Replace,
+                        index: index + 1,
+                        count: 0,
+                        cells: ( (newLinesContents.slice(1).map(line => ({
+                            cellKind: kind,
+                            language,
+                            mime,
+                            source: line,
+                            outputs: [],
+                            metadata: {}
+                        }))))
+                    })))
+                ], { quotableLabel: 'Split Notebook Cell' });
+            }
+        }
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: JOIN_CELL_ABOVE_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 5, "Join With Previous Cell")),
+            keybinding: {
+                when: NOTEBOOK_EDITOR_FOCUSED,
+                primary: KeyMod.WinCtrl | KeyMod.Alt | KeyMod.Shift | KeyCode.KeyJ,
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 10
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const bulkEditService = accessor.get(IBulkEditService);
+        return joinCellsWithSurrounds(bulkEditService, context, 'above');
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: JOIN_CELL_BELOW_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 6, "Join With Next Cell")),
+            keybinding: {
+                when: NOTEBOOK_EDITOR_FOCUSED,
+                primary: KeyMod.WinCtrl | KeyMod.Alt | KeyCode.KeyJ,
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 11
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const bulkEditService = accessor.get(IBulkEditService);
+        return joinCellsWithSurrounds(bulkEditService, context, 'below');
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: JOIN_SELECTED_CELLS_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 7, "Join Selected Cells")),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE))),
+                group: CellOverflowToolbarGroups.Edit,
+                order: 12
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const bulkEditService = accessor.get(IBulkEditService);
+        const notificationService = accessor.get(INotificationService);
+        return joinSelectedCells(bulkEditService, notificationService, context);
+    }
+});
+const CHANGE_CELL_TO_CODE_COMMAND_ID = 'notebook.cell.changeToCode';
+const CHANGE_CELL_TO_MARKDOWN_COMMAND_ID = 'notebook.cell.changeToMarkdown';
+registerAction2(class ChangeCellToCodeAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: CHANGE_CELL_TO_CODE_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 8, "Change Cell to Code")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_FOCUSED,
+                    ContextKeyExpr.not(InputFocusedContextKey),
+                     (NOTEBOOK_OUTPUT_FOCUSED.toNegated())
+                ))),
+                primary: KeyCode.KeyY,
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            precondition: ( (ContextKeyExpr.and(
+                NOTEBOOK_IS_ACTIVE_EDITOR,
+                 (NOTEBOOK_CELL_TYPE.isEqualTo('markup'))
+            ))),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_FOCUSED,
+                    NOTEBOOK_EDITOR_EDITABLE,
+                    NOTEBOOK_CELL_EDITABLE,
+                     (NOTEBOOK_CELL_TYPE.isEqualTo('markup'))
+                ))),
+                group: CellOverflowToolbarGroups.Edit,
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        await changeCellToKind(CellKind.Code, context);
+    }
+});
+registerAction2(class ChangeCellToMarkdownAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: CHANGE_CELL_TO_MARKDOWN_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 9, "Change Cell to Markdown")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_FOCUSED,
+                    ContextKeyExpr.not(InputFocusedContextKey),
+                     (NOTEBOOK_OUTPUT_FOCUSED.toNegated())
+                ))),
+                primary: KeyCode.KeyM,
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            precondition: ( (ContextKeyExpr.and(
+                NOTEBOOK_IS_ACTIVE_EDITOR,
+                 (NOTEBOOK_CELL_TYPE.isEqualTo('code'))
+            ))),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_EDITOR_FOCUSED,
+                    NOTEBOOK_EDITOR_EDITABLE,
+                    NOTEBOOK_CELL_EDITABLE,
+                     (NOTEBOOK_CELL_TYPE.isEqualTo('code'))
+                ))),
+                group: CellOverflowToolbarGroups.Edit,
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        await changeCellToKind(CellKind.Markup, context, 'markdown', Mimes.markdown);
+    }
+});
+const COLLAPSE_CELL_INPUT_COMMAND_ID = 'notebook.cell.collapseCellInput';
+const COLLAPSE_CELL_OUTPUT_COMMAND_ID = 'notebook.cell.collapseCellOutput';
+const COLLAPSE_ALL_CELL_INPUTS_COMMAND_ID = 'notebook.cell.collapseAllCellInputs';
+const EXPAND_ALL_CELL_INPUTS_COMMAND_ID = 'notebook.cell.expandAllCellInputs';
+const COLLAPSE_ALL_CELL_OUTPUTS_COMMAND_ID = 'notebook.cell.collapseAllCellOutputs';
+const EXPAND_ALL_CELL_OUTPUTS_COMMAND_ID = 'notebook.cell.expandAllCellOutputs';
+const TOGGLE_CELL_OUTPUTS_COMMAND_ID = 'notebook.cell.toggleOutputs';
+const TOGGLE_CELL_OUTPUT_SCROLLING = 'notebook.cell.toggleOutputScrolling';
+registerAction2(class CollapseCellInputAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: COLLAPSE_CELL_INPUT_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 10, "Collapse Cell Input")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_CELL_LIST_FOCUSED,
+                     (NOTEBOOK_CELL_INPUT_COLLAPSED.toNegated()),
+                     (InputFocusedContext.toNegated())
+                ))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyC),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    parseArgs(accessor, ...args) {
+        return parseMultiCellExecutionArgs(accessor, ...args);
+    }
+    async runWithContext(accessor, context) {
+        if (context.ui) {
+            context.cell.isInputCollapsed = true;
+        }
+        else {
+            context.selectedCells.forEach(cell => cell.isInputCollapsed = true);
+        }
+    }
+});
+registerAction2(class ExpandCellInputAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: EXPAND_CELL_INPUT_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 11, "Expand Cell Input")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_CELL_INPUT_COLLAPSED))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyC),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    parseArgs(accessor, ...args) {
+        return parseMultiCellExecutionArgs(accessor, ...args);
+    }
+    async runWithContext(accessor, context) {
+        if (context.ui) {
+            context.cell.isInputCollapsed = false;
+        }
+        else {
+            context.selectedCells.forEach(cell => cell.isInputCollapsed = false);
+        }
+    }
+});
+registerAction2(class CollapseCellOutputAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: COLLAPSE_CELL_OUTPUT_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 12, "Collapse Cell Output")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_CELL_LIST_FOCUSED,
+                     (NOTEBOOK_CELL_OUTPUT_COLLAPSED.toNegated()),
+                     (InputFocusedContext.toNegated()),
+                    NOTEBOOK_CELL_HAS_OUTPUTS
+                ))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyT),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        if (context.ui) {
+            context.cell.isOutputCollapsed = true;
+        }
+        else {
+            context.selectedCells.forEach(cell => cell.isOutputCollapsed = true);
+        }
+    }
+});
+registerAction2(class ExpandCellOuputAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: EXPAND_CELL_OUTPUT_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 13, "Expand Cell Output")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_CELL_OUTPUT_COLLAPSED))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyT),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        if (context.ui) {
+            context.cell.isOutputCollapsed = false;
+        }
+        else {
+            context.selectedCells.forEach(cell => cell.isOutputCollapsed = false);
+        }
+    }
+});
+registerAction2(class extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: TOGGLE_CELL_OUTPUTS_COMMAND_ID,
+            precondition: NOTEBOOK_CELL_LIST_FOCUSED,
+            title: ( localize2WithPath(_moduleId, 14, "Toggle Outputs")),
+            metadata: {
+                description: ( localizeWithPath(_moduleId, 14, "Toggle Outputs")),
+                args: cellExecutionArgs
+            }
+        });
+    }
+    parseArgs(accessor, ...args) {
+        return parseMultiCellExecutionArgs(accessor, ...args);
+    }
+    async runWithContext(accessor, context) {
+        let cells = [];
+        if (context.ui) {
+            cells = [context.cell];
+        }
+        else if (context.selectedCells) {
+            cells = context.selectedCells;
+        }
+        for (const cell of cells) {
+            cell.isOutputCollapsed = !cell.isOutputCollapsed;
+        }
+    }
+});
+registerAction2(class CollapseAllCellInputsAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: COLLAPSE_ALL_CELL_INPUTS_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 15, "Collapse All Cell Inputs")),
+            f1: true,
+        });
+    }
+    async runWithContext(accessor, context) {
+        forEachCell(context.notebookEditor, cell => cell.isInputCollapsed = true);
+    }
+});
+registerAction2(class ExpandAllCellInputsAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: EXPAND_ALL_CELL_INPUTS_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 16, "Expand All Cell Inputs")),
+            f1: true
+        });
+    }
+    async runWithContext(accessor, context) {
+        forEachCell(context.notebookEditor, cell => cell.isInputCollapsed = false);
+    }
+});
+registerAction2(class CollapseAllCellOutputsAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: COLLAPSE_ALL_CELL_OUTPUTS_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 17, "Collapse All Cell Outputs")),
+            f1: true,
+        });
+    }
+    async runWithContext(accessor, context) {
+        forEachCell(context.notebookEditor, cell => cell.isOutputCollapsed = true);
+    }
+});
+registerAction2(class ExpandAllCellOutputsAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: EXPAND_ALL_CELL_OUTPUTS_COMMAND_ID,
+            title: ( localize2WithPath(_moduleId, 18, "Expand All Cell Outputs")),
+            f1: true
+        });
+    }
+    async runWithContext(accessor, context) {
+        forEachCell(context.notebookEditor, cell => cell.isOutputCollapsed = false);
+    }
+});
+registerAction2(class ToggleCellOutputScrolling extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: TOGGLE_CELL_OUTPUT_SCROLLING,
+            title: ( localize2WithPath(_moduleId, 19, "Toggle Scroll Cell Output")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                    NOTEBOOK_CELL_LIST_FOCUSED,
+                     (InputFocusedContext.toNegated()),
+                    NOTEBOOK_CELL_HAS_OUTPUTS
+                ))),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyY),
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    toggleOutputScrolling(viewModel, globalScrollSetting, collapsed) {
+        const cellMetadata = viewModel.model.metadata;
+        if (cellMetadata) {
+            const currentlyEnabled = cellMetadata['scrollable'] !== undefined ? cellMetadata['scrollable'] : globalScrollSetting;
+            const shouldEnableScrolling = collapsed || !currentlyEnabled;
+            cellMetadata['scrollable'] = shouldEnableScrolling;
+            viewModel.resetRenderer();
+        }
+    }
+    async runWithContext(accessor, context) {
+        const globalScrolling = accessor.get(IConfigurationService).getValue(NotebookSetting.outputScrolling);
+        if (context.ui) {
+            context.cell.outputsViewModels.forEach((viewModel) => {
+                this.toggleOutputScrolling(viewModel, globalScrolling, context.cell.isOutputCollapsed);
+            });
+            context.cell.isOutputCollapsed = false;
+        }
+        else {
+            context.selectedCells.forEach(cell => {
+                cell.outputsViewModels.forEach((viewModel) => {
+                    this.toggleOutputScrolling(viewModel, globalScrolling, cell.isOutputCollapsed);
+                });
+                cell.isOutputCollapsed = false;
+            });
+        }
+    }
+});
+function forEachCell(editor, callback) {
+    for (let i = 0; i < editor.getLength(); i++) {
+        const cell = editor.cellAt(i);
+        callback(cell, i);
+    }
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellDiagnostics/cellDiagnosticEditorContrib.js

@@ -0,0 +1,133 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers.service';
+import { NotebookExecutionType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { CodeCellViewModel } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+
+var CellDiagnostics_1;
+let CellDiagnostics = class CellDiagnostics extends Disposable {
+    static { CellDiagnostics_1 = this; }
+    static { this.ID = 'workbench.notebook.cellDiagnostics'; }
+    constructor(notebookEditor, notebookExecutionStateService, markerService, chatAgentService, configurationService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.markerService = markerService;
+        this.chatAgentService = chatAgentService;
+        this.configurationService = configurationService;
+        this.enabled = false;
+        this.listening = false;
+        this.diagnosticsByHandle = ( new Map());
+        this.updateEnabled();
+        this._register(chatAgentService.onDidChangeAgents(() => this.updateEnabled()));
+        this._register(configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration(NotebookSetting.cellFailureDiagnostics)) {
+                this.updateEnabled();
+            }
+        }));
+    }
+    updateEnabled() {
+        const settingEnabled = this.configurationService.getValue(NotebookSetting.cellFailureDiagnostics);
+        if (this.enabled && (!settingEnabled || Iterable.isEmpty(this.chatAgentService.getAgents()))) {
+            this.enabled = false;
+            this.clearAll();
+        }
+        else if (!this.enabled && settingEnabled && !Iterable.isEmpty(this.chatAgentService.getAgents())) {
+            this.enabled = true;
+            if (!this.listening) {
+                this.listening = true;
+                this._register(Event.accumulate(this.notebookExecutionStateService.onDidChangeExecution, 200)((e) => this.handleChangeExecutionState(e)));
+            }
+        }
+    }
+    handleChangeExecutionState(changes) {
+        if (!this.enabled) {
+            return;
+        }
+        const handled = ( new Set());
+        for (const e of changes.reverse()) {
+            const notebookUri = this.notebookEditor.textModel?.uri;
+            if (e.type === NotebookExecutionType.cell && notebookUri && e.affectsNotebook(notebookUri) && !( handled.has(e.cellHandle))) {
+                handled.add(e.cellHandle);
+                if (!!e.changed) {
+                    this.clear(e.cellHandle);
+                }
+                else {
+                    this.setDiagnostics(e.cellHandle);
+                }
+            }
+        }
+    }
+    clearAll() {
+        for (const handle of ( this.diagnosticsByHandle.keys())) {
+            this.clear(handle);
+        }
+    }
+    clear(cellHandle) {
+        const diagnostic = this.diagnosticsByHandle.get(cellHandle);
+        if (diagnostic) {
+            for (const disposable of diagnostic.disposables) {
+                disposable.dispose();
+            }
+            this.diagnosticsByHandle.delete(cellHandle);
+        }
+    }
+    setDiagnostics(cellHandle) {
+        if (( this.diagnosticsByHandle.has(cellHandle))) {
+            return;
+        }
+        const cell = this.notebookEditor.getCellByHandle(cellHandle);
+        if (!cell || cell.cellKind !== CellKind.Code) {
+            return;
+        }
+        const metadata = cell.model.internalMetadata;
+        if (cell instanceof CodeCellViewModel && !metadata.lastRunSuccess && metadata?.error?.location) {
+            const disposables = [];
+            const marker = this.createMarkerData(metadata.error.message, metadata.error.location);
+            this.markerService.changeOne(CellDiagnostics_1.ID, cell.uri, [marker]);
+            disposables.push(toDisposable(() => this.markerService.changeOne(CellDiagnostics_1.ID, cell.uri, [])));
+            cell.excecutionError.set(metadata.error, undefined);
+            disposables.push(toDisposable(() => cell.excecutionError.set(undefined, undefined)));
+            disposables.push(cell.model.onDidChangeOutputs(() => {
+                if (cell.model.outputs.length === 0) {
+                    this.clear(cellHandle);
+                }
+            }));
+            disposables.push(cell.model.onDidChangeContent(() => {
+                this.clear(cellHandle);
+            }));
+            this.diagnosticsByHandle.set(cellHandle, { cellUri: cell.uri, error: metadata.error, disposables });
+        }
+    }
+    createMarkerData(message, location) {
+        return {
+            severity: 8,
+            message: message,
+            startLineNumber: location.startLineNumber + 1,
+            startColumn: location.startColumn + 1,
+            endLineNumber: location.endLineNumber + 1,
+            endColumn: location.endColumn + 1,
+            source: 'Cell Execution Error'
+        };
+    }
+    dispose() {
+        super.dispose();
+        this.clearAll();
+    }
+};
+CellDiagnostics = CellDiagnostics_1 = ( __decorate([
+    ( __param(1, INotebookExecutionStateService)),
+    ( __param(2, IMarkerService)),
+    ( __param(3, IChatAgentService)),
+    ( __param(4, IConfigurationService))
+], CellDiagnostics));
+registerNotebookContribution(CellDiagnostics.ID, CellDiagnostics);
+
+export { CellDiagnostics };