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

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

@@ -1,165 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { debugIconBreakpointForeground } from 'vscode/vscode/vs/workbench/contrib/debug/browser/breakpointEditorContribution';
-import { topStackFrameColor, focusedStackFrameColor } from 'vscode/vscode/vs/workbench/contrib/debug/browser/callStackEditorContribution';
-import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { NotebookOverviewRulerLane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
-import { runningCellRulerDecorationColor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
-import { NotebookCellExecutionState, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookExecutionType, INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-
-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

@@ -1,67 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { EmptyTextEditorHintContribution } from '../../../../codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js';
-import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
-import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-
-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

@@ -1,320 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Disposable, DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
-import { CENTER_ACTIVE_CELL } from '../navigation/arrow.js';
-import { SELECT_KERNEL_ID } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { SELECT_NOTEBOOK_INDENTATION_ID } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/editActions';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
-
-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 };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/execute/executionEditorProgress.js

@@ -1,72 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { throttle } from 'vscode/vscode/vs/base/common/decorators';
-import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
-import { NotebookCellExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
-
-let ExecutionEditorProgressController = class ExecutionEditorProgressController extends Disposable {
-    static { this.id = 'workbench.notebook.executionEditorProgress'; }
-    constructor(_notebookEditor, _notebookExecutionStateService, _userActivity) {
-        super();
-        this._notebookEditor = _notebookEditor;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this._userActivity = _userActivity;
-        this._activityMutex = this._register(( new MutableDisposable()));
-        this._register(_notebookEditor.onDidScroll(() => this._update()));
-        this._register(_notebookExecutionStateService.onDidChangeExecution(e => {
-            if (( e.notebook.toString()) !== this._notebookEditor.textModel?.uri.toString()) {
-                return;
-            }
-            this._update();
-        }));
-        this._register(_notebookEditor.onDidChangeModel(() => this._update()));
-    }
-    _update() {
-        if (!this._notebookEditor.hasModel()) {
-            return;
-        }
-        const cellExecutions = this._notebookExecutionStateService.getCellExecutionsForNotebook(this._notebookEditor.textModel?.uri)
-            .filter(exe => exe.state === NotebookCellExecutionState.Executing);
-        const notebookExecution = this._notebookExecutionStateService.getExecution(this._notebookEditor.textModel?.uri);
-        const executionIsVisible = (exe) => {
-            for (const range of this._notebookEditor.visibleRanges) {
-                for (const cell of this._notebookEditor.getCellsInRange(range)) {
-                    if (cell.handle === exe.cellHandle) {
-                        const top = this._notebookEditor.getAbsoluteTopOfElement(cell);
-                        if (this._notebookEditor.scrollTop < top + 5) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            return false;
-        };
-        const hasAnyExecution = cellExecutions.length || notebookExecution;
-        if (hasAnyExecution && !this._activityMutex.value) {
-            this._activityMutex.value = this._userActivity.markActive();
-        }
-        else if (!hasAnyExecution && this._activityMutex.value) {
-            this._activityMutex.clear();
-        }
-        const shouldShowEditorProgressbarForCellExecutions = cellExecutions.length && !( cellExecutions.some(executionIsVisible)) && !( cellExecutions.some(e => e.isPaused));
-        const showEditorProgressBar = !!notebookExecution || shouldShowEditorProgressbarForCellExecutions;
-        if (showEditorProgressBar) {
-            this._notebookEditor.showProgress();
-        }
-        else {
-            this._notebookEditor.hideProgress();
-        }
-    }
-};
-ExecutionEditorProgressController.__decorator = ( __decorate([
-    throttle(100)
-], ExecutionEditorProgressController.prototype, "_update", null));
-ExecutionEditorProgressController = ( __decorate([
-    ( __param(1, INotebookExecutionStateService)),
-    ( __param(2, IUserActivityService))
-], ExecutionEditorProgressController));
-registerNotebookContribution(ExecutionEditorProgressController.id, ExecutionEditorProgressController);
-
-export { ExecutionEditorProgressController };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/media/notebookFind.css.js

@@ -1,6 +0,0 @@
-import n from '../../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-
-var css = ".monaco-workbench .notebookOverlay.notebook-editor.find-hide-transition,.monaco-workbench .notebookOverlay.notebook-editor.find-show-transition{overflow-y:hidden}.monaco-workbench .notebookOverlay.notebook-editor .simple-fr-find-part-wrapper .matchesCount{box-sizing:border-box;overflow:hidden;padding:0 2px;text-align:center;text-overflow:ellipsis;white-space:nowrap}";
-n(css,{});
-
-export { css, css as default };