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

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/layout/layoutActions.js

@@ -0,0 +1,67 @@
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { NOTEBOOK_ACTIONS_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const TOGGLE_CELL_TOOLBAR_POSITION = 'notebook.toggleCellToolbarPosition';
+class ToggleCellToolbarPositionAction extends Action2 {
+    constructor() {
+        super({
+            id: TOGGLE_CELL_TOOLBAR_POSITION,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/layout/layoutActions',
+                'notebook.toggleCellToolbarPosition',
+                'Toggle Cell Toolbar Position'
+            )),
+            menu: [{
+                    id: MenuId.NotebookCellTitle,
+                    group: 'View',
+                    order: 1
+                }],
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            f1: false
+        });
+    }
+    async run(accessor, context) {
+        const editor = context && context.ui ? context.notebookEditor : undefined;
+        if (editor && editor.hasModel()) {
+            const viewType = editor.textModel.viewType;
+            const configurationService = accessor.get(IConfigurationService);
+            const toolbarPosition = configurationService.getValue(NotebookSetting.cellToolbarLocation);
+            const newConfig = this.togglePosition(viewType, toolbarPosition);
+            await configurationService.updateValue(NotebookSetting.cellToolbarLocation, newConfig);
+        }
+    }
+    togglePosition(viewType, toolbarPosition) {
+        if (typeof toolbarPosition === 'string') {
+            if (['left', 'right', 'hidden'].indexOf(toolbarPosition) >= 0) {
+                const newViewValue = toolbarPosition === 'right' ? 'left' : 'right';
+                const config = {
+                    default: toolbarPosition
+                };
+                config[viewType] = newViewValue;
+                return config;
+            }
+            else {
+                const config = {
+                    default: 'right',
+                };
+                config[viewType] = 'left';
+                return config;
+            }
+        }
+        else {
+            const oldValue = toolbarPosition[viewType] ?? toolbarPosition['default'] ?? 'right';
+            const newViewValue = oldValue === 'right' ? 'left' : 'right';
+            const newConfig = {
+                ...toolbarPosition
+            };
+            newConfig[viewType] = newViewValue;
+            return newConfig;
+        }
+    }
+}
+registerAction2(ToggleCellToolbarPositionAction);
+
+export { ToggleCellToolbarPositionAction };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/marker/markerProvider.js

@@ -0,0 +1,101 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { MarkerList, IMarkerNavigationService } from 'vscode/vscode/vs/editor/contrib/gotoError/browser/markerNavigationService';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { MarkerSeverity, IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { NotebookOverviewRulerLane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { throttle } from 'vscode/vscode/vs/base/common/decorators';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorErrorForeground, editorWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+
+let MarkerListProvider = class MarkerListProvider {
+    static { this.ID = 'workbench.contrib.markerListProvider'; }
+    constructor(_markerService, markerNavigation, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._dispoables = markerNavigation.registerProvider(this);
+    }
+    dispose() {
+        this._dispoables.dispose();
+    }
+    getMarkerList(resource) {
+        if (!resource) {
+            return undefined;
+        }
+        const data = CellUri.parse(resource);
+        if (!data) {
+            return undefined;
+        }
+        return ( new MarkerList(uri => {
+            const otherData = CellUri.parse(uri);
+            return otherData?.notebook.toString() === ( data.notebook.toString());
+        }, this._markerService, this._configService));
+    }
+};
+MarkerListProvider = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IMarkerNavigationService)),
+    ( __param(2, IConfigurationService))
+], MarkerListProvider));
+let NotebookMarkerDecorationContribution = class NotebookMarkerDecorationContribution extends Disposable {
+    static { this.id = 'workbench.notebook.markerDecoration'; }
+    constructor(_notebookEditor, _markerService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._markerService = _markerService;
+        this._markersOverviewRulerDecorations = [];
+        this._update();
+        this._register(this._notebookEditor.onDidChangeModel(() => this._update()));
+        this._register(this._markerService.onMarkerChanged(e => {
+            if (( e.some(uri => ( this._notebookEditor.getCellsInRange().some(cell => isEqual(cell.uri, uri)))))) {
+                this._update();
+            }
+        }));
+    }
+    _update() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const cellDecorations = [];
+        this._notebookEditor.getCellsInRange().forEach(cell => {
+            const marker = this._markerService.read({ resource: cell.uri, severities: MarkerSeverity.Error | MarkerSeverity.Warning });
+            marker.forEach(m => {
+                const color = m.severity === MarkerSeverity.Error ? editorErrorForeground : editorWarningForeground;
+                const range = { startLineNumber: m.startLineNumber, startColumn: m.startColumn, endLineNumber: m.endLineNumber, endColumn: m.endColumn };
+                cellDecorations.push({
+                    handle: cell.handle,
+                    options: {
+                        overviewRuler: {
+                            color: color,
+                            modelRanges: [range],
+                            includeOutput: false,
+                            position: NotebookOverviewRulerLane.Right
+                        }
+                    }
+                });
+            });
+        });
+        this._markersOverviewRulerDecorations = this._notebookEditor.deltaCellDecorations(this._markersOverviewRulerDecorations, cellDecorations);
+    }
+};
+NotebookMarkerDecorationContribution.__decorator = ( __decorate([
+    throttle(100)
+], NotebookMarkerDecorationContribution.prototype, "_update", null));
+NotebookMarkerDecorationContribution = ( __decorate([
+    ( __param(1, IMarkerService))
+], NotebookMarkerDecorationContribution));
+registerWorkbenchContribution2(MarkerListProvider.ID, MarkerListProvider, 2 );
+registerNotebookContribution(NotebookMarkerDecorationContribution.id, NotebookMarkerDecorationContribution);

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/navigation/arrow.js

@@ -0,0 +1,393 @@
+import { timeout } from 'vscode/vscode/vs/base/common/async';
+import { EditorExtensionsRegistry } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
+import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { InputFocusedContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext';
+import { NotebookCellAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, findTargetCellEditor, NotebookAction } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NOTEBOOK_EDITOR_CURSOR_BOUNDARY, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CURSOR_NAVIGATION_MODE, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_CELL_HAS_OUTPUTS } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+
+const NOTEBOOK_FOCUS_TOP = 'notebook.focusTop';
+const NOTEBOOK_FOCUS_BOTTOM = 'notebook.focusBottom';
+const NOTEBOOK_FOCUS_PREVIOUS_EDITOR = 'notebook.focusPreviousEditor';
+const NOTEBOOK_FOCUS_NEXT_EDITOR = 'notebook.focusNextEditor';
+const FOCUS_IN_OUTPUT_COMMAND_ID = 'notebook.cell.focusInOutput';
+const FOCUS_OUT_OUTPUT_COMMAND_ID = 'notebook.cell.focusOutOutput';
+const CENTER_ACTIVE_CELL = 'notebook.centerActiveCell';
+const NOTEBOOK_CURSOR_PAGEUP_COMMAND_ID = 'notebook.cell.cursorPageUp';
+const NOTEBOOK_CURSOR_PAGEUP_SELECT_COMMAND_ID = 'notebook.cell.cursorPageUpSelect';
+const NOTEBOOK_CURSOR_PAGEDOWN_COMMAND_ID = 'notebook.cell.cursorPageDown';
+const NOTEBOOK_CURSOR_PAGEDOWN_SELECT_COMMAND_ID = 'notebook.cell.cursorPageDownSelect';
+registerAction2(class FocusNextCellAction extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_FOCUS_NEXT_EDITOR,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorMoveDown',
+                'Focus Next Cell Editor'
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true)), ( ContextKeyExpr.and(( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus, ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('top')), ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('none')))), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 18 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                },
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true)), ( ContextKeyExpr.and(( NOTEBOOK_CELL_TYPE.isEqualTo('markup')), ( NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.isEqualTo(false)), NOTEBOOK_CURSOR_NAVIGATION_MODE)), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 18 ,
+                    weight: 200 ,
+                },
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED)),
+                    primary: 2048  | 18 ,
+                    mac: { primary: 256  | 2048  | 18 , },
+                    weight: 200
+                },
+                {
+                    when: NOTEBOOK_EDITOR_FOCUSED,
+                    primary: 2048  | 512  | 12 ,
+                    mac: { primary: 2048  | 512  | 12 , },
+                    weight: 200
+                },
+            ]
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        const activeCell = context.cell;
+        const idx = editor.getCellIndex(activeCell);
+        if (typeof idx !== 'number') {
+            return;
+        }
+        if (idx >= editor.getLength() - 1) {
+            return;
+        }
+        const focusEditorLine = activeCell.textBuffer.getLineCount();
+        const targetCell = (context.cell ?? context.selectedCells?.[0]);
+        const foundEditor = targetCell ? findTargetCellEditor(context, targetCell) : undefined;
+        if (foundEditor && foundEditor.hasTextFocus() && InlineChatController.get(foundEditor)?.getWidgetPosition()?.lineNumber === focusEditorLine) {
+            InlineChatController.get(foundEditor)?.focus();
+        }
+        else {
+            const newCell = editor.cellAt(idx + 1);
+            const newFocusMode = newCell.cellKind === CellKind.Markup && newCell.getEditState() === CellEditState.Preview ? 'container' : 'editor';
+            await editor.focusNotebookCell(newCell, newFocusMode, { focusEditorLine: 1 });
+        }
+    }
+});
+registerAction2(class FocusPreviousCellAction extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_FOCUS_PREVIOUS_EDITOR,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorMoveUp',
+                'Focus Previous Cell Editor'
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true)), ( ContextKeyExpr.and(( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus, ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('bottom')), ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('none')))), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 16 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                },
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true)), ( ContextKeyExpr.and(( NOTEBOOK_CELL_TYPE.isEqualTo('markup')), ( NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.isEqualTo(false)), NOTEBOOK_CURSOR_NAVIGATION_MODE)), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 16 ,
+                    weight: 200 ,
+                },
+                {
+                    when: NOTEBOOK_EDITOR_FOCUSED,
+                    primary: 2048  | 512  | 11 ,
+                    mac: { primary: 2048  | 512  | 11  },
+                    weight: 200
+                },
+            ],
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        const activeCell = context.cell;
+        const idx = editor.getCellIndex(activeCell);
+        if (typeof idx !== 'number') {
+            return;
+        }
+        if (idx < 1 || editor.getLength() === 0) {
+            return;
+        }
+        const newCell = editor.cellAt(idx - 1);
+        const newFocusMode = newCell.cellKind === CellKind.Markup && newCell.getEditState() === CellEditState.Preview ? 'container' : 'editor';
+        const focusEditorLine = newCell.textBuffer.getLineCount();
+        await editor.focusNotebookCell(newCell, newFocusMode, { focusEditorLine: focusEditorLine });
+        const foundEditor = findTargetCellEditor(context, newCell);
+        if (foundEditor && InlineChatController.get(foundEditor)?.getWidgetPosition()?.lineNumber === focusEditorLine) {
+            InlineChatController.get(foundEditor)?.focus();
+        }
+    }
+});
+registerAction2(class extends NotebookAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_FOCUS_TOP,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'focusFirstCell',
+                'Focus First Cell'
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                    primary: 2048  | 14 ,
+                    weight: 200
+                },
+                {
+                    when: ( ContextKeyExpr.and(
+                        NOTEBOOK_EDITOR_FOCUSED,
+                        ContextKeyExpr.not(InputFocusedContextKey),
+                        ( CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION.isEqualTo(''))
+                    )),
+                    mac: { primary: 2048  | 16  },
+                    weight: 200
+                }
+            ],
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        if (editor.getLength() === 0) {
+            return;
+        }
+        const firstCell = editor.cellAt(0);
+        await editor.focusNotebookCell(firstCell, 'container');
+    }
+});
+registerAction2(class extends NotebookAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_FOCUS_BOTTOM,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'focusLastCell',
+                'Focus Last Cell'
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                    primary: 2048  | 13 ,
+                    mac: undefined,
+                    weight: 200
+                },
+                {
+                    when: ( ContextKeyExpr.and(
+                        NOTEBOOK_EDITOR_FOCUSED,
+                        ContextKeyExpr.not(InputFocusedContextKey),
+                        ( CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION.isEqualTo(''))
+                    )),
+                    mac: { primary: 2048  | 18  },
+                    weight: 200
+                }
+            ],
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        if (!editor.hasModel() || editor.getLength() === 0) {
+            return;
+        }
+        const lastIdx = editor.getLength() - 1;
+        const lastVisibleIdx = editor.getPreviousVisibleCellIndex(lastIdx);
+        if (lastVisibleIdx) {
+            const cell = editor.cellAt(lastVisibleIdx);
+            await editor.focusNotebookCell(cell, 'container');
+        }
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: FOCUS_IN_OUTPUT_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'focusOutput',
+                'Focus In Active Cell Output'
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_CELL_HAS_OUTPUTS)),
+                primary: 2048  | 18 ,
+                mac: { primary: 256  | 2048  | 18 , },
+                weight: 200
+            },
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        const activeCell = context.cell;
+        return timeout(0).then(() => editor.focusNotebookCell(activeCell, 'output'));
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: FOCUS_OUT_OUTPUT_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'focusOutputOut',
+                'Focus Out Active Cell Output'
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED)),
+                primary: 2048  | 16 ,
+                mac: { primary: 256  | 2048  | 16 , },
+                weight: 200
+            },
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editor = context.notebookEditor;
+        const activeCell = context.cell;
+        await editor.focusNotebookCell(activeCell, 'editor');
+    }
+});
+registerAction2(class CenterActiveCellAction extends NotebookCellAction {
+    constructor() {
+        super({
+            id: CENTER_ACTIVE_CELL,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'notebookActions.centerActiveCell',
+                "Center Active Cell"
+            )),
+            keybinding: {
+                when: NOTEBOOK_EDITOR_FOCUSED,
+                primary: 2048  | 42 ,
+                mac: {
+                    primary: 256  | 42 ,
+                },
+                weight: 200
+            },
+        });
+    }
+    async runWithContext(accessor, context) {
+        return context.notebookEditor.revealInCenter(context.cell);
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_CURSOR_PAGEUP_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorPageUp',
+                "Cell Cursor Page Up"
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus)),
+                    primary: 11 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }
+            ]
+        });
+    }
+    async runWithContext(accessor, context) {
+        EditorExtensionsRegistry.getEditorCommand('cursorPageUp').runCommand(accessor, { pageSize: getPageSize(context) });
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_CURSOR_PAGEUP_SELECT_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorPageUpSelect',
+                "Cell Cursor Page Up Select"
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus, ( NOTEBOOK_OUTPUT_FOCUSED.negate()))),
+                    primary: 1024  | 11 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }
+            ]
+        });
+    }
+    async runWithContext(accessor, context) {
+        EditorExtensionsRegistry.getEditorCommand('cursorPageUpSelect').runCommand(accessor, { pageSize: getPageSize(context) });
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_CURSOR_PAGEDOWN_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorPageDown',
+                "Cell Cursor Page Down"
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus)),
+                    primary: 12 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }
+            ]
+        });
+    }
+    async runWithContext(accessor, context) {
+        EditorExtensionsRegistry.getEditorCommand('cursorPageDown').runCommand(accessor, { pageSize: getPageSize(context) });
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_CURSOR_PAGEDOWN_SELECT_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'cursorPageDownSelect',
+                "Cell Cursor Page Down Select"
+            )),
+            keybinding: [
+                {
+                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.has(InputFocusedContextKey)), EditorContextKeys.editorTextFocus, ( NOTEBOOK_OUTPUT_FOCUSED.negate()))),
+                    primary: 1024  | 12 ,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }
+            ]
+        });
+    }
+    async runWithContext(accessor, context) {
+        EditorExtensionsRegistry.getEditorCommand('cursorPageDownSelect').runCommand(accessor, { pageSize: getPageSize(context) });
+    }
+});
+function getPageSize(context) {
+    const editor = context.notebookEditor;
+    const layoutInfo = editor.getViewModel().layoutInfo;
+    const lineHeight = layoutInfo?.fontInfo.lineHeight || 17;
+    return Math.max(1, Math.floor((layoutInfo?.height || 0) / lineHeight) - 2);
+}
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'notebook',
+    order: 100,
+    type: 'object',
+    'properties': {
+        'notebook.navigation.allowNavigateToSurroundingCells': {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow',
+                'notebook.navigation.allowNavigateToSurroundingCells',
+                "When enabled cursor can navigate to the next/previous cell when the current cursor in the cell editor is at the first/last line."
+            ))
+        }
+    }
+});
+
+export { CENTER_ACTIVE_CELL };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableContextKeys.js

@@ -0,0 +1,5 @@
+import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+
+const NOTEBOOK_VARIABLE_VIEW_ENABLED = ( new RawContextKey('notebookVariableViewEnabled', false));
+
+export { NOTEBOOK_VARIABLE_VIEW_ENABLED };

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

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/views';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { NOTEBOOK_VARIABLE_VIEW_ENABLED } from './notebookVariableContextKeys.js';
+import { NotebookVariablesView } from './notebookVariablesView.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { variablesViewIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+let NotebookVariables = class NotebookVariables extends Disposable {
+    constructor(contextKeyService, configurationService, editorService, notebookExecutionStateService, notebookKernelService, notebookDocumentService) {
+        super();
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.notebookKernelService = notebookKernelService;
+        this.notebookDocumentService = notebookDocumentService;
+        this.listeners = [];
+        this.initialized = false;
+        this.viewEnabled = NOTEBOOK_VARIABLE_VIEW_ENABLED.bindTo(contextKeyService);
+        this.listeners.push(this.editorService.onDidActiveEditorChange(() => this.handleInitEvent()));
+        this.listeners.push(this.notebookExecutionStateService.onDidChangeExecution((e) => this.handleInitEvent(e.notebook)));
+        this.configListener = configurationService.onDidChangeConfiguration((e) => this.handleConfigChange(e));
+    }
+    handleConfigChange(e) {
+        if (e.affectsConfiguration(NotebookSetting.notebookVariablesView)) {
+            if (!this.configurationService.getValue(NotebookSetting.notebookVariablesView)) {
+                this.viewEnabled.set(false);
+            }
+            else if (this.initialized) {
+                this.viewEnabled.set(true);
+            }
+            else {
+                this.handleInitEvent();
+            }
+        }
+    }
+    handleInitEvent(notebook) {
+        if (this.configurationService.getValue(NotebookSetting.notebookVariablesView)
+            && (!!notebook || this.editorService.activeEditorPane?.getId() === 'workbench.editor.notebook')) {
+            if (this.hasVariableProvider(notebook) && !this.initialized && this.initializeView()) {
+                this.viewEnabled.set(true);
+                this.initialized = true;
+                this.listeners.forEach(listener => listener.dispose());
+            }
+        }
+    }
+    hasVariableProvider(notebookUri) {
+        const notebook = notebookUri ?
+            this.notebookDocumentService.getNotebookTextModel(notebookUri) :
+            getNotebookEditorFromEditorPane(this.editorService.activeEditorPane)?.getViewModel()?.notebookDocument;
+        return notebook && this.notebookKernelService.getMatchingKernel(notebook).selected?.hasVariableProvider;
+    }
+    initializeView() {
+        const debugViewContainer = ( Registry.as('workbench.registry.view.containers')).get(VIEWLET_ID);
+        if (debugViewContainer) {
+            const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+            const viewDescriptor = {
+                id: 'NOTEBOOK_VARIABLES', name: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariables',
+                'notebookVariables',
+                "Notebook Variables"
+            )),
+                containerIcon: variablesViewIcon, ctorDescriptor: ( new SyncDescriptor(NotebookVariablesView)),
+                order: 50, weight: 5, canToggleVisibility: true, canMoveView: true, collapsed: true, when: NOTEBOOK_VARIABLE_VIEW_ENABLED,
+            };
+            viewsRegistry.registerViews([viewDescriptor], debugViewContainer);
+            return true;
+        }
+        return false;
+    }
+    dispose() {
+        super.dispose();
+        this.listeners.forEach(listener => listener.dispose());
+        this.configListener.dispose();
+    }
+};
+NotebookVariables = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, INotebookKernelService)),
+    ( __param(5, INotebookService))
+], NotebookVariables));
+
+export { NotebookVariables };