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

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

@@ -0,0 +1,165 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.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 { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { EmptyTextEditorHintContribution } from '../../../../codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+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

@@ -0,0 +1,238 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } 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 { 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: ( nls.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 ? ( nls.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: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'notebook.select',
+                    "Notebook Kernel Selection"
+                )),
+                text: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                    'kernel.select.label',
+                    "Select Kernel"
+                )),
+                ariaLabel: ( nls.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: ( nls.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 ?
+            ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
+                'notebook.multiActiveCellIndicator',
+                "Cell {0} ({1} selected)",
+                idxFocused,
+                numSelected
+            )) :
+            ( nls.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 );
+
+export { ActiveCellStatus, KernelStatus };

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

@@ -0,0 +1,72 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { throttle } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+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

@@ -0,0 +1,6 @@
+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 };