@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookCellPausing.js

@@ -0,0 +1,66 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../../../../base/common/async.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../../../common/contributions.js';
+import { IDebugService } from '../../../../debug/common/debug.js';
+import { CellUri } from '../../../common/notebookCommon.js';
+import { CellExecutionUpdateType } from '../../../common/notebookExecutionService.js';
+import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+let NotebookCellPausing = class NotebookCellPausing extends Disposable {
+    constructor(_debugService, _notebookExecutionStateService) {
+        super();
+        this._debugService = _debugService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._pausedCells = ( new Set());
+        this._register(_debugService.getModel().onDidChangeCallStack(() => {
+            this.onDidChangeCallStack(true);
+            this._scheduler.schedule();
+        }));
+        this._scheduler = this._register(( new RunOnceScheduler(() => this.onDidChangeCallStack(false), 2000)));
+    }
+    async onDidChangeCallStack(fallBackOnStaleCallstack) {
+        const newPausedCells = ( new Set());
+        for (const session of this._debugService.getModel().getSessions()) {
+            for (const thread of session.getAllThreads()) {
+                let callStack = thread.getCallStack();
+                if (fallBackOnStaleCallstack && !callStack.length) {
+                    callStack = thread.getStaleCallStack();
+                }
+                callStack.forEach(sf => {
+                    const parsed = CellUri.parse(sf.source.uri);
+                    if (parsed) {
+                        newPausedCells.add(( sf.source.uri.toString()));
+                        this.editIsPaused(sf.source.uri, true);
+                    }
+                });
+            }
+        }
+        for (const uri of this._pausedCells) {
+            if (!( newPausedCells.has(uri))) {
+                this.editIsPaused(( URI.parse(uri)), false);
+                this._pausedCells.delete(uri);
+            }
+        }
+        newPausedCells.forEach(cell => this._pausedCells.add(cell));
+    }
+    editIsPaused(cellUri, isPaused) {
+        const parsed = CellUri.parse(cellUri);
+        if (parsed) {
+            const exeState = this._notebookExecutionStateService.getCellExecution(cellUri);
+            if (exeState && (exeState.isPaused !== isPaused || !exeState.didPause)) {
+                exeState.update([{
+                        editType: CellExecutionUpdateType.ExecutionState,
+                        didPause: true,
+                        isPaused
+                    }]);
+            }
+        }
+    }
+};
+NotebookCellPausing = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, INotebookExecutionStateService))
+], NotebookCellPausing));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookCellPausing, 3 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookDebugDecorations.js

@@ -0,0 +1,163 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { Range } from '../../../../../../editor/common/core/range.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { debugIconBreakpointForeground } from '../../../../debug/browser/breakpointEditorContribution.js';
+import { topStackFrameColor, focusedStackFrameColor } from '../../../../debug/browser/callStackEditorContribution.js';
+import { IDebugService } from '../../../../debug/common/debug.js';
+import { NotebookOverviewRulerLane } from '../../notebookBrowser.js';
+import { registerNotebookContribution } from '../../notebookEditorExtensions.js';
+import { runningCellRulerDecorationColor } from '../../notebookEditorWidget.js';
+import { CellUri, NotebookCellExecutionState } from '../../../common/notebookCommon.js';
+import { NotebookExecutionType, INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+let PausedCellDecorationContribution = class PausedCellDecorationContribution extends Disposable {
+    static { this.id = 'workbench.notebook.debug.pausedCellDecorations'; }
+    constructor(_notebookEditor, _debugService, _notebookExecutionStateService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._debugService = _debugService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._currentTopDecorations = [];
+        this._currentOtherDecorations = [];
+        this._executingCellDecorations = [];
+        this._register(_debugService.getModel().onDidChangeCallStack(() => this.updateExecutionDecorations()));
+        this._register(_debugService.getViewModel().onDidFocusStackFrame(() => this.updateExecutionDecorations()));
+        this._register(_notebookExecutionStateService.onDidChangeExecution(e => {
+            if (e.type === NotebookExecutionType.cell && this._notebookEditor.textModel && e.affectsNotebook(this._notebookEditor.textModel.uri)) {
+                this.updateExecutionDecorations();
+            }
+        }));
+    }
+    updateExecutionDecorations() {
+        const exes = this._notebookEditor.textModel ?
+            this._notebookExecutionStateService.getCellExecutionsByHandleForNotebook(this._notebookEditor.textModel.uri)
+            : undefined;
+        const topFrameCellsAndRanges = [];
+        let focusedFrameCellAndRange = undefined;
+        const getNotebookCellAndRange = (sf) => {
+            const parsed = CellUri.parse(sf.source.uri);
+            if (parsed && ( parsed.notebook.toString()) === this._notebookEditor.textModel?.uri.toString()) {
+                return { handle: parsed.handle, range: sf.range };
+            }
+            return undefined;
+        };
+        for (const session of this._debugService.getModel().getSessions()) {
+            for (const thread of session.getAllThreads()) {
+                const topFrame = thread.getTopStackFrame();
+                if (topFrame) {
+                    const notebookCellAndRange = getNotebookCellAndRange(topFrame);
+                    if (notebookCellAndRange) {
+                        topFrameCellsAndRanges.push(notebookCellAndRange);
+                        exes?.delete(notebookCellAndRange.handle);
+                    }
+                }
+            }
+        }
+        const focusedFrame = this._debugService.getViewModel().focusedStackFrame;
+        if (focusedFrame && focusedFrame.thread.stopped) {
+            const thisFocusedFrameCellAndRange = getNotebookCellAndRange(focusedFrame);
+            if (thisFocusedFrameCellAndRange &&
+                !( topFrameCellsAndRanges.some(
+                    topFrame => topFrame.handle === thisFocusedFrameCellAndRange?.handle && Range.equalsRange(topFrame.range, thisFocusedFrameCellAndRange?.range)
+                ))) {
+                focusedFrameCellAndRange = thisFocusedFrameCellAndRange;
+                exes?.delete(focusedFrameCellAndRange.handle);
+            }
+        }
+        this.setTopFrameDecoration(topFrameCellsAndRanges);
+        this.setFocusedFrameDecoration(focusedFrameCellAndRange);
+        const exeHandles = exes ?
+            ( Array.from(exes.entries())
+                .filter(([_, exe]) => exe.state === NotebookCellExecutionState.Executing)
+                .map(([handle]) => handle))
+            : [];
+        this.setExecutingCellDecorations(exeHandles);
+    }
+    setTopFrameDecoration(handlesAndRanges) {
+        const newDecorations = ( handlesAndRanges.map(({ handle, range }) => {
+            const options = {
+                overviewRuler: {
+                    color: topStackFrameColor,
+                    includeOutput: false,
+                    modelRanges: [range],
+                    position: NotebookOverviewRulerLane.Full
+                }
+            };
+            return { handle, options };
+        }));
+        this._currentTopDecorations = this._notebookEditor.deltaCellDecorations(this._currentTopDecorations, newDecorations);
+    }
+    setFocusedFrameDecoration(focusedFrameCellAndRange) {
+        let newDecorations = [];
+        if (focusedFrameCellAndRange) {
+            const options = {
+                overviewRuler: {
+                    color: focusedStackFrameColor,
+                    includeOutput: false,
+                    modelRanges: [focusedFrameCellAndRange.range],
+                    position: NotebookOverviewRulerLane.Full
+                }
+            };
+            newDecorations = [{ handle: focusedFrameCellAndRange.handle, options }];
+        }
+        this._currentOtherDecorations = this._notebookEditor.deltaCellDecorations(this._currentOtherDecorations, newDecorations);
+    }
+    setExecutingCellDecorations(handles) {
+        const newDecorations = ( handles.map(handle => {
+            const options = {
+                overviewRuler: {
+                    color: runningCellRulerDecorationColor,
+                    includeOutput: false,
+                    modelRanges: [( new Range(0, 0, 0, 0))],
+                    position: NotebookOverviewRulerLane.Left
+                }
+            };
+            return { handle, options };
+        }));
+        this._executingCellDecorations = this._notebookEditor.deltaCellDecorations(this._executingCellDecorations, newDecorations);
+    }
+};
+PausedCellDecorationContribution = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, INotebookExecutionStateService))
+], PausedCellDecorationContribution));
+registerNotebookContribution(PausedCellDecorationContribution.id, PausedCellDecorationContribution);
+let NotebookBreakpointDecorations = class NotebookBreakpointDecorations extends Disposable {
+    static { this.id = 'workbench.notebook.debug.notebookBreakpointDecorations'; }
+    constructor(_notebookEditor, _debugService, _configService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._debugService = _debugService;
+        this._configService = _configService;
+        this._currentDecorations = [];
+        this._register(_debugService.getModel().onDidChangeBreakpoints(() => this.updateDecorations()));
+        this._register(_configService.onDidChangeConfiguration(e => e.affectsConfiguration('debug.showBreakpointsInOverviewRuler') && this.updateDecorations()));
+    }
+    updateDecorations() {
+        const enabled = this._configService.getValue('debug.showBreakpointsInOverviewRuler');
+        const newDecorations = enabled ?
+            ( this._debugService.getModel().getBreakpoints().map(breakpoint => {
+                const parsed = CellUri.parse(breakpoint.uri);
+                if (!parsed || ( parsed.notebook.toString()) !== ( this._notebookEditor.textModel.uri.toString())) {
+                    return null;
+                }
+                const options = {
+                    overviewRuler: {
+                        color: debugIconBreakpointForeground,
+                        includeOutput: false,
+                        modelRanges: [( new Range(breakpoint.lineNumber, 0, breakpoint.lineNumber, 0))],
+                        position: NotebookOverviewRulerLane.Left
+                    }
+                };
+                return { handle: parsed.handle, options };
+            })).filter(x => !!x)
+            : [];
+        this._currentDecorations = this._notebookEditor.deltaCellDecorations(this._currentDecorations, newDecorations);
+    }
+};
+NotebookBreakpointDecorations = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IConfigurationService))
+], NotebookBreakpointDecorations));
+registerNotebookContribution(NotebookBreakpointDecorations.id, NotebookBreakpointDecorations);
+export { NotebookBreakpointDecorations, PausedCellDecorationContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/editorHint/emptyCellEditorHint.js

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from '../../../../../../base/common/network.js';
+import { registerEditorContribution } from '../../../../../../editor/browser/editorExtensions.js';
+import { ICommandService } from '../../../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { IKeybindingService } from '../../../../../../platform/keybinding/common/keybinding.js';
+import { IProductService } from '../../../../../../platform/product/common/productService.js';
+import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.js';
+import { EmptyTextEditorHintContribution } from '../../../../codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js';
+import { IInlineChatSessionService } from '../../../../inlineChat/browser/inlineChatSessionService.js';
+import { IInlineChatService } from '../../../../inlineChat/common/inlineChat.js';
+import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
+import { IEditorGroupsService } from '../../../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+let EmptyCellEditorHintContribution = class EmptyCellEditorHintContribution extends EmptyTextEditorHintContribution {
+    static { this.CONTRIB_ID = 'notebook.editor.contrib.emptyCellEditorHint'; }
+    constructor(editor, _editorService, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService) {
+        super(editor, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService);
+        this._editorService = _editorService;
+        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        if (!activeEditor) {
+            return;
+        }
+        this.toDispose.push(activeEditor.onDidChangeActiveCell(() => this.update()));
+    }
+    _getOptions() {
+        return { clickable: false };
+    }
+    _shouldRenderHint() {
+        const shouldRenderHint = super._shouldRenderHint();
+        if (!shouldRenderHint) {
+            return false;
+        }
+        const model = this.editor.getModel();
+        if (!model) {
+            return false;
+        }
+        const isNotebookCell = model?.uri.scheme === Schemas.vscodeNotebookCell;
+        if (!isNotebookCell) {
+            return false;
+        }
+        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        if (!activeEditor) {
+            return false;
+        }
+        const activeCell = activeEditor.getActiveCell();
+        if (activeCell?.uri.fragment !== model.uri.fragment) {
+            return false;
+        }
+        return true;
+    }
+};
+EmptyCellEditorHintContribution = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, IEditorGroupsService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IInlineChatSessionService)),
+    ( __param(7, IInlineChatService)),
+    ( __param(8, ITelemetryService)),
+    ( __param(9, IProductService))
+], EmptyCellEditorHintContribution));
+registerEditorContribution(EmptyCellEditorHintContribution.CONTRIB_ID, EmptyCellEditorHintContribution, 0 );
+export { EmptyCellEditorHintContribution };

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

@@ -0,0 +1,318 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../../../nls.js';
+import { Disposable, DisposableStore, MutableDisposable } from '../../../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../../../base/common/network.js';
+import { ILanguageFeaturesService } from '../../../../../../editor/common/services/languageFeatures.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../../../platform/log/common/log.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { Extensions, registerWorkbenchContribution2 } from '../../../../../common/contributions.js';
+import { CENTER_ACTIVE_CELL } from '../navigation/arrow.js';
+import { SELECT_KERNEL_ID } from '../../controller/coreActions.js';
+import { SELECT_NOTEBOOK_INDENTATION_ID } from '../../controller/editActions.js';
+import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
+import { NotebookCellsChangeType } from '../../../common/notebookCommon.js';
+import { INotebookKernelService } from '../../../common/notebookKernelService.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+import { IStatusbarService } from '../../../../../services/statusbar/browser/statusbar.js';
+let ImplictKernelSelector = class ImplictKernelSelector {
+    constructor(notebook, suggested, notebookKernelService, languageFeaturesService, logService) {
+        const disposables = ( new DisposableStore());
+        this.dispose = disposables.dispose.bind(disposables);
+        const selectKernel = () => {
+            disposables.clear();
+            notebookKernelService.selectKernelForNotebook(suggested, notebook);
+        };
+        disposables.add(notebook.onDidChangeContent(e => {
+            for (const event of e.rawEvents) {
+                switch (event.kind) {
+                    case NotebookCellsChangeType.ChangeCellContent:
+                    case NotebookCellsChangeType.ModelChange:
+                    case NotebookCellsChangeType.Move:
+                    case NotebookCellsChangeType.ChangeCellLanguage:
+                        logService.trace('IMPLICIT kernel selection because of change event', event.kind);
+                        selectKernel();
+                        break;
+                }
+            }
+        }));
+        disposables.add(languageFeaturesService.hoverProvider.register({ scheme: Schemas.vscodeNotebookCell, pattern: notebook.uri.path }, {
+            provideHover() {
+                logService.trace('IMPLICIT kernel selection because of hover');
+                selectKernel();
+                return undefined;
+            }
+        }));
+    }
+};
+ImplictKernelSelector = ( __decorate([
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, ILogService))
+], ImplictKernelSelector));
+let KernelStatus = class KernelStatus extends Disposable {
+    constructor(_editorService, _statusbarService, _notebookKernelService, _instantiationService) {
+        super();
+        this._editorService = _editorService;
+        this._statusbarService = _statusbarService;
+        this._notebookKernelService = _notebookKernelService;
+        this._instantiationService = _instantiationService;
+        this._editorDisposables = this._register(( new DisposableStore()));
+        this._kernelInfoElement = this._register(( new DisposableStore()));
+        this._register(this._editorService.onDidActiveEditorChange(() => this._updateStatusbar()));
+    }
+    _updateStatusbar() {
+        this._editorDisposables.clear();
+        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        if (!activeEditor) {
+            this._kernelInfoElement.clear();
+            return;
+        }
+        const updateStatus = () => {
+            if (activeEditor.notebookOptions.getDisplayOptions().globalToolbar) {
+                this._kernelInfoElement.clear();
+                return;
+            }
+            const notebook = activeEditor.textModel;
+            if (notebook) {
+                this._showKernelStatus(notebook);
+            }
+            else {
+                this._kernelInfoElement.clear();
+            }
+        };
+        this._editorDisposables.add(this._notebookKernelService.onDidAddKernel(updateStatus));
+        this._editorDisposables.add(this._notebookKernelService.onDidChangeSelectedNotebooks(updateStatus));
+        this._editorDisposables.add(this._notebookKernelService.onDidChangeNotebookAffinity(updateStatus));
+        this._editorDisposables.add(activeEditor.onDidChangeModel(updateStatus));
+        this._editorDisposables.add(activeEditor.notebookOptions.onDidChangeOptions(updateStatus));
+        updateStatus();
+    }
+    _showKernelStatus(notebook) {
+        this._kernelInfoElement.clear();
+        const { selected, suggestions, all } = this._notebookKernelService.getMatchingKernel(notebook);
+        const suggested = (suggestions.length === 1 ? suggestions[0] : undefined)
+            ?? (all.length === 1) ? all[0] : undefined;
+        let isSuggested = false;
+        if (all.length === 0) {
+            return;
+        }
+        else if (selected || suggested) {
+            let kernel = selected;
+            if (!kernel) {
+                kernel = suggested;
+                isSuggested = true;
+                this._kernelInfoElement.add(this._instantiationService.createInstance(ImplictKernelSelector, notebook, kernel));
+            }
+            const tooltip = kernel.description ?? kernel.detail ?? kernel.label;
+            this._kernelInfoElement.add(this._statusbarService.addEntry({
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'notebook.info',
+                    "Notebook Kernel Info"
+                )),
+                text: `$(notebook-kernel-select) ${kernel.label}`,
+                ariaLabel: kernel.label,
+                tooltip: isSuggested ? ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'tooltop',
+                    "{0} (suggestion)",
+                    tooltip
+                )) : tooltip,
+                command: SELECT_KERNEL_ID,
+            }, SELECT_KERNEL_ID, 1 , 10));
+            this._kernelInfoElement.add(kernel.onDidChange(() => this._showKernelStatus(notebook)));
+        }
+        else {
+            this._kernelInfoElement.add(this._statusbarService.addEntry({
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'notebook.select',
+                    "Notebook Kernel Selection"
+                )),
+                text: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'kernel.select.label',
+                    "Select Kernel"
+                )),
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'kernel.select.label',
+                    "Select Kernel"
+                )),
+                command: SELECT_KERNEL_ID,
+                kind: 'prominent'
+            }, SELECT_KERNEL_ID, 1 , 10));
+        }
+    }
+};
+KernelStatus = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, IInstantiationService))
+], KernelStatus));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(KernelStatus, 3 );
+let ActiveCellStatus = class ActiveCellStatus extends Disposable {
+    constructor(_editorService, _statusbarService) {
+        super();
+        this._editorService = _editorService;
+        this._statusbarService = _statusbarService;
+        this._itemDisposables = this._register(( new DisposableStore()));
+        this._accessor = this._register(( new MutableDisposable()));
+        this._register(this._editorService.onDidActiveEditorChange(() => this._update()));
+    }
+    _update() {
+        this._itemDisposables.clear();
+        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        if (activeEditor) {
+            this._itemDisposables.add(activeEditor.onDidChangeSelection(() => this._show(activeEditor)));
+            this._itemDisposables.add(activeEditor.onDidChangeActiveCell(() => this._show(activeEditor)));
+            this._show(activeEditor);
+        }
+        else {
+            this._accessor.clear();
+        }
+    }
+    _show(editor) {
+        if (!editor.hasModel()) {
+            this._accessor.clear();
+            return;
+        }
+        const newText = this._getSelectionsText(editor);
+        if (!newText) {
+            this._accessor.clear();
+            return;
+        }
+        const entry = {
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'notebook.activeCellStatusName',
+                "Notebook Editor Selections"
+            )),
+            text: newText,
+            ariaLabel: newText,
+            command: CENTER_ACTIVE_CELL
+        };
+        if (!this._accessor.value) {
+            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.activeCellStatus', 1 , 100);
+        }
+        else {
+            this._accessor.value.update(entry);
+        }
+    }
+    _getSelectionsText(editor) {
+        if (!editor.hasModel()) {
+            return undefined;
+        }
+        const activeCell = editor.getActiveCell();
+        if (!activeCell) {
+            return undefined;
+        }
+        const idxFocused = editor.getCellIndex(activeCell) + 1;
+        const numSelected = editor.getSelections().reduce((prev, range) => prev + (range.end - range.start), 0);
+        const totalCells = editor.getLength();
+        return numSelected > 1 ?
+            ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'notebook.multiActiveCellIndicator',
+                "Cell {0} ({1} selected)",
+                idxFocused,
+                numSelected
+            )) :
+            ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'notebook.singleActiveCellIndicator',
+                "Cell {0} of {1}",
+                idxFocused,
+                totalCells
+            ));
+    }
+};
+ActiveCellStatus = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStatusbarService))
+], ActiveCellStatus));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ActiveCellStatus, 3 );
+let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposable {
+    static { this.ID = 'selectNotebookIndentation'; }
+    constructor(_editorService, _statusbarService, _configurationService) {
+        super();
+        this._editorService = _editorService;
+        this._statusbarService = _statusbarService;
+        this._configurationService = _configurationService;
+        this._itemDisposables = this._register(( new DisposableStore()));
+        this._accessor = this._register(( new MutableDisposable()));
+        this._register(this._editorService.onDidActiveEditorChange(() => this._update()));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor') || e.affectsConfiguration('notebook')) {
+                this._update();
+            }
+        }));
+    }
+    _update() {
+        this._itemDisposables.clear();
+        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        if (activeEditor) {
+            this._show(activeEditor);
+            this._itemDisposables.add(activeEditor.onDidChangeSelection(() => {
+                this._accessor.clear();
+                this._show(activeEditor);
+            }));
+        }
+        else {
+            this._accessor.clear();
+        }
+    }
+    _show(editor) {
+        if (!editor.hasModel()) {
+            this._accessor.clear();
+            return;
+        }
+        const cellOptions = editor.getActiveCell()?.textModel?.getOptions();
+        if (!cellOptions) {
+            this._accessor.clear();
+            return;
+        }
+        const cellEditorOverridesRaw = editor.notebookOptions.getDisplayOptions().editorOptionsCustomizations;
+        const indentSize = cellEditorOverridesRaw['editor.indentSize'] ?? cellOptions?.indentSize;
+        const insertSpaces = cellEditorOverridesRaw['editor.insertSpaces'] ?? cellOptions?.tabSize;
+        const tabSize = cellEditorOverridesRaw['editor.tabSize'] ?? cellOptions?.insertSpaces;
+        const width = typeof indentSize === 'number' ? indentSize : tabSize;
+        const message = insertSpaces ? `Spaces: ${width}` : `Tab Size: ${width}`;
+        const newText = message;
+        if (!newText) {
+            this._accessor.clear();
+            return;
+        }
+        const entry = {
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'notebook.indentation',
+                "Notebook Indentation"
+            )),
+            text: newText,
+            ariaLabel: newText,
+            tooltip: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'selectNotebookIndentation',
+                "Select Indentation"
+            )),
+            command: SELECT_NOTEBOOK_INDENTATION_ID
+        };
+        if (!this._accessor.value) {
+            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.status.indentation', 1 , 100.4);
+        }
+        else {
+            this._accessor.value.update(entry);
+        }
+    }
+};
+NotebookIndentationStatus = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, IConfigurationService))
+], NotebookIndentationStatus));
+registerWorkbenchContribution2(NotebookIndentationStatus.ID, NotebookIndentationStatus, 3 );
+export { ActiveCellStatus, KernelStatus, NotebookIndentationStatus };