@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,383 @@
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { InputFocusedContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+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: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true)), ( ContextKeyExpr.and(( ContextKeyExpr.has(InputFocusedContextKey)), ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('top')), ( NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('none')))), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 18 ,
+                    weight: 0
+                },
+                {
+                    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)), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: 18 ,
+                    weight: 0
+                },
+                {
+                    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'
+            )),
+            precondition: ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()),
+            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 ,
+                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: { 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)),
+                    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)),
+                    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/notebookVariables.js

@@ -0,0 +1,51 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/views';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { NotebookVariablesView } from './notebookVariablesView.js';
+import { NOTEBOOK_KERNEL } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { variablesViewIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+
+let NotebookVariables = class NotebookVariables extends Disposable {
+    constructor(editorService, configurationService) {
+        super();
+        this.editorService = editorService;
+        this.listener = this.editorService.onDidEditorsChange(() => {
+            if (configurationService.getValue('notebook.experimental.notebookVariablesView')
+                && this.editorService.activeEditorPane?.getId() === 'workbench.editor.notebook') {
+                if (this.initializeView()) {
+                    this.listener?.dispose();
+                }
+            }
+        });
+    }
+    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: ( nls.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: ( ContextKeyExpr.notEquals(NOTEBOOK_KERNEL.key, '')),
+            };
+            viewsRegistry.registerViews([viewDescriptor], debugViewContainer);
+            return true;
+        }
+        return false;
+    }
+};
+NotebookVariables = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IConfigurationService))
+], NotebookVariables));
+
+export { NotebookVariables };

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

@@ -0,0 +1,46 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+class NotebookVariablesDelegate {
+    getHeight(element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        return NotebookVariableRenderer.ID;
+    }
+}
+class NotebookVariableRenderer {
+    static { this.ID = 'variableElement'; }
+    get templateId() {
+        return NotebookVariableRenderer.ID;
+    }
+    renderTemplate(container) {
+        const wrapper = dom.append(container, dom.$('.variable'));
+        return { wrapper };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.wrapper.innerText = `${element.element.label} - ${element.element.value}`;
+    }
+    disposeTemplate() {
+    }
+}
+class NotebookVariableAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree',
+            'debugConsole',
+            "Notebook Variables"
+        ));
+    }
+    getAriaLabel(element) {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree',
+            'notebookVariableAriaLabel',
+            "Variable {0}, value {1}",
+            element.label,
+            element.value
+        ));
+    }
+}
+
+export { NotebookVariableAccessibilityProvider, NotebookVariableRenderer, NotebookVariablesDelegate };

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

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.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 { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { WorkbenchObjectTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { NotebookVariablesDelegate, NotebookVariableRenderer, NotebookVariableAccessibilityProvider } from './notebookVariablesTree.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
+    static { this.ID = 'notebookVariablesView'; }
+    static { this.TITLE = ( nls.localize2WithPath(
+        'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView',
+        'notebook.notebookVariables',
+        "Notebook Variables"
+    )); }
+    constructor(options, editorService, notebookKernelService, notebookExecutionStateService, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, themeService, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorService = editorService;
+        this.notebookKernelService = notebookKernelService;
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.quickInputService = quickInputService;
+        this.commandService = commandService;
+        this.index = 0;
+        this._register(this.editorService.onDidActiveEditorChange(this.handleActiveEditorChange.bind(this)));
+        this._register(this.notebookExecutionStateService.onDidChangeExecution(this.handleExecutionStateChange.bind(this)));
+        this._register(this.notebookKernelService.onDidNotebookVariablesUpdate(this.handleVariablesChanged.bind(this)));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.tree = this.instantiationService.createInstance(WorkbenchObjectTree, 'notebookVariablesTree', container, ( new NotebookVariablesDelegate()), [( new NotebookVariableRenderer())], {
+            identityProvider: { getId: (e) => e.id },
+            horizontalScrolling: false,
+            supportDynamicHeights: true,
+            hideTwistiesOfChildlessElements: true,
+            accessibilityProvider: ( new NotebookVariableAccessibilityProvider()),
+            setRowLineHeight: false,
+        });
+        this.tree.layout();
+        this.tree?.setChildren(null, []);
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.tree?.layout(height, width);
+    }
+    handleActiveEditorChange() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        if (activeEditorPane && activeEditorPane.getId() === 'workbench.editor.notebook') {
+            const notebookDocument = getNotebookEditorFromEditorPane(activeEditorPane)?.getViewModel()?.notebookDocument;
+            if (notebookDocument && notebookDocument !== this.activeNotebook) {
+                this.activeNotebook = notebookDocument;
+                this.updateVariables(this.activeNotebook);
+            }
+        }
+    }
+    handleExecutionStateChange(event) {
+        if (this.activeNotebook) {
+            if (event.changed === undefined && event.affectsNotebook(this.activeNotebook?.uri)) {
+                this.updateVariables(this.activeNotebook);
+            }
+        }
+    }
+    handleVariablesChanged(notebookUri) {
+        if (this.activeNotebook && ( notebookUri.toString()) === ( this.activeNotebook.uri.toString())) {
+            this.updateVariables(this.activeNotebook);
+        }
+    }
+    async updateVariables(notebook) {
+        const selectedKernel = this.notebookKernelService.getMatchingKernel(notebook).selected;
+        if (selectedKernel && selectedKernel.hasVariableProvider) {
+            const variables = selectedKernel.provideVariables(notebook.uri, undefined, 'named', 0, CancellationToken.None);
+            const treeData = await ( variables
+                .map(variable => { return this.createTreeItem(variable); }))
+                .toPromise();
+            this.tree?.setChildren(null, treeData);
+        }
+    }
+    createTreeItem(variable) {
+        let collapsed = undefined;
+        let children = undefined;
+        if (variable.namedChildrenCount > 0 || variable.indexedChildrenCount > 0) {
+            collapsed = true;
+            children = [
+                {
+                    element: {
+                        id: `${this.index + 1}-placeholder`,
+                        label: ' ',
+                        value: 'loading...',
+                    }
+                }
+            ];
+        }
+        const element = {
+            element: {
+                id: `${this.index++}`,
+                label: variable.variable.name,
+                value: variable.variable.value,
+            },
+            children,
+            collapsed
+        };
+        return element;
+    }
+};
+NotebookVariablesView = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IQuickInputService)),
+    ( __param(12, ICommandService)),
+    ( __param(13, IThemeService)),
+    ( __param(14, ITelemetryService))
+], NotebookVariablesView));
+
+export { NotebookVariablesView };