@codingame/monaco-vscode-katex-common 26.1.2 → 26.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-katex-common",
-  "version": "26.1.2",
+  "version": "26.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on katex",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "26.1.2",
+    "@codingame/monaco-vscode-api": "26.2.0",
     "katex": "0.16.27",
     "marked": "14.0.0"
   },

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.d.ts

@@ -0,0 +1,7 @@
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare const INTERACTIVE_INPUT_CURSOR_BOUNDARY: RawContextKey<"top" | "none" | "bottom" | "both">;
+export declare const ReplEditorSettings: {
+    interactiveWindowAlwaysScrollOnNewCell: string;
+    executeWithShiftEnter: string;
+    showExecutionHint: string;
+};

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.js

@@ -0,0 +1,11 @@
+
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+const INTERACTIVE_INPUT_CURSOR_BOUNDARY = ( new RawContextKey("interactiveInputCursorAtBoundary", "none"));
+const ReplEditorSettings = {
+    interactiveWindowAlwaysScrollOnNewCell: "interactiveWindow.alwaysScrollOnNewCell",
+    executeWithShiftEnter: "interactiveWindow.executeWithShiftEnter",
+    showExecutionHint: "interactiveWindow.showExecutionHint"
+};
+
+export { INTERACTIVE_INPUT_CURSOR_BOUNDARY, ReplEditorSettings };

package/vscode/src/vs/workbench/contrib/interactive/browser/replInputHintContentWidget.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor, IContentWidget, IContentWidgetPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+export declare class ReplInputHintContentWidget extends Disposable implements IContentWidget {
+    private readonly editor;
+    private readonly configurationService;
+    private readonly keybindingService;
+    private static readonly ID;
+    private domNode;
+    private ariaLabel;
+    private label;
+    constructor(editor: ICodeEditor, configurationService: IConfigurationService, keybindingService: IKeybindingService);
+    getId(): string;
+    getPosition(): IContentWidgetPosition | null;
+    getDomNode(): HTMLElement;
+    private setHint;
+    private getKeybinding;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/interactive/browser/replInputHintContentWidget.js

@@ -0,0 +1,150 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { KeybindingLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ContentWidgetPositionPreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { AccessibilityCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { ReplEditorSettings } from './interactiveCommon.js';
+
+var ReplInputHintContentWidget_1;
+let ReplInputHintContentWidget = class ReplInputHintContentWidget extends Disposable {
+    static {
+        ReplInputHintContentWidget_1 = this;
+    }
+    static {
+        this.ID = "replInput.widget.emptyHint";
+    }
+    constructor(editor, configurationService, keybindingService) {
+        super();
+        this.editor = editor;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.ariaLabel = "";
+        this._register(this.editor.onDidChangeConfiguration(e => {
+            if (this.domNode && e.hasChanged(EditorOption.fontInfo)) {
+                this.editor.applyFontInfo(this.domNode);
+            }
+        }));
+        const onDidFocusEditorText = Event.debounce(this.editor.onDidFocusEditorText, () => undefined, 500);
+        this._register(onDidFocusEditorText(() => {
+            if (this.editor.hasTextFocus() && this.ariaLabel && configurationService.getValue(AccessibilityVerbositySettingId.ReplEditor)) {
+                status(this.ariaLabel);
+            }
+        }));
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ReplEditorSettings.executeWithShiftEnter)) {
+                this.setHint();
+            }
+        }));
+        this.editor.addContentWidget(this);
+    }
+    getId() {
+        return ReplInputHintContentWidget_1.ID;
+    }
+    getPosition() {
+        return {
+            position: {
+                lineNumber: 1,
+                column: 1
+            },
+            preference: [ContentWidgetPositionPreference.EXACT]
+        };
+    }
+    getDomNode() {
+        if (!this.domNode) {
+            this.domNode = $(".empty-editor-hint");
+            this.domNode.style.width = "max-content";
+            this.domNode.style.paddingLeft = "4px";
+            this.setHint();
+            this._register(addDisposableListener(this.domNode, "click", () => {
+                this.editor.focus();
+            }));
+            this.editor.applyFontInfo(this.domNode);
+            const lineHeight = this.editor.getLineHeightForPosition(( new Position(1, 1)));
+            this.domNode.style.lineHeight = lineHeight + "px";
+        }
+        return this.domNode;
+    }
+    setHint() {
+        if (!this.domNode) {
+            return;
+        }
+        while (this.domNode.firstChild) {
+            this.domNode.removeChild(this.domNode.firstChild);
+        }
+        const hintElement = $("div.empty-hint-text");
+        hintElement.style.cursor = "text";
+        hintElement.style.whiteSpace = "nowrap";
+        const keybinding = this.getKeybinding();
+        const keybindingHintLabel = keybinding?.getLabel();
+        if (keybinding && keybindingHintLabel) {
+            const actionPart = ( localize(8901, "Press {0} to execute. ", keybindingHintLabel));
+            const [before, after] = ( actionPart.split(keybindingHintLabel).map(fragment => {
+                const hintPart = $("span", undefined, fragment);
+                hintPart.style.fontStyle = "italic";
+                return hintPart;
+            }));
+            hintElement.appendChild(before);
+            if (this.label) {
+                this.label.dispose();
+            }
+            this.label = this._register(( new KeybindingLabel(hintElement, OS)));
+            this.label.set(keybinding);
+            this.label.element.style.width = "min-content";
+            this.label.element.style.display = "inline";
+            hintElement.appendChild(after);
+            this.domNode.append(hintElement);
+            const helpKeybinding = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            const helpInfo = helpKeybinding ? ( localize(8902, "Use {0} for accessibility help. ", helpKeybinding)) : ( localize(8903, "Run the Open Accessibility Help command for more information. "));
+            this.ariaLabel = actionPart.concat(helpInfo, ( localize(
+                8904,
+                " Toggle {0} in settings to disable this hint.",
+                AccessibilityVerbositySettingId.ReplEditor
+            )));
+        }
+    }
+    getKeybinding() {
+        const keybindings = this.keybindingService.lookupKeybindings("interactive.execute");
+        const shiftEnterConfig = this.configurationService.getValue(ReplEditorSettings.executeWithShiftEnter);
+        const hasEnterChord = (kb, modifier = "") => {
+            const chords = kb.getDispatchChords();
+            const chord = modifier + "Enter";
+            const chordAlt = modifier + "[Enter]";
+            return chords.length === 1 && (chords[0] === chord || chords[0] === chordAlt);
+        };
+        if (shiftEnterConfig) {
+            const keybinding = keybindings.find(kb => hasEnterChord(kb, "shift+"));
+            if (keybinding) {
+                return keybinding;
+            }
+        } else {
+            let keybinding = keybindings.find(kb => hasEnterChord(kb));
+            if (keybinding) {
+                return keybinding;
+            }
+            keybinding = this.keybindingService.lookupKeybindings("python.execInREPLEnter").find(kb => hasEnterChord(kb));
+            if (keybinding) {
+                return keybinding;
+            }
+        }
+        return keybindings?.[0];
+    }
+    dispose() {
+        super.dispose();
+        this.editor.removeContentWidget(this);
+        this.label?.dispose();
+    }
+};
+ReplInputHintContentWidget = ReplInputHintContentWidget_1 = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, IKeybindingService))], ReplInputHintContentWidget));
+
+export { ReplInputHintContentWidget };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController.d.ts

@@ -0,0 +1,22 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ICellViewModel, INotebookEditor, INotebookEditorContribution, INotebookViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+export declare function formatCellDuration(duration: number, showMilliseconds?: boolean): string;
+export declare class NotebookStatusBarController extends Disposable {
+    private readonly _notebookEditor;
+    private readonly _itemFactory;
+    private readonly _visibleCells;
+    private readonly _observer;
+    constructor(_notebookEditor: INotebookEditor, _itemFactory: (vm: INotebookViewModel, cell: ICellViewModel) => IDisposable);
+    private _updateEverything;
+    private _updateVisibleCells;
+    dispose(): void;
+}
+export declare class ExecutionStateCellStatusBarContrib extends Disposable implements INotebookEditorContribution {
+    static id: string;
+    constructor(notebookEditor: INotebookEditor, instantiationService: IInstantiationService);
+}
+export declare class TimerCellStatusBarContrib extends Disposable implements INotebookEditorContribution {
+    static id: string;
+    constructor(notebookEditor: INotebookEditor, instantiationService: IInstantiationService);
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController.js

@@ -0,0 +1,338 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, dispose, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { language } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { NotebookVisibleCellObserver } from './notebookVisibleCellObserver.js';
+import { registerNotebookContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { cellStatusIconSuccess, cellStatusIconError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
+import { successStateIcon, errorStateIcon, pendingStateIcon, executingStateIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { NotebookCellExecutionState, CellStatusbarAlignment, NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NotebookExecutionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+
+var ExecutionStateCellStatusBarItem_1, TimerCellStatusBarItem_1;
+function formatCellDuration(duration, showMilliseconds = true) {
+    if (showMilliseconds && duration < 1000) {
+        return `${duration}ms`;
+    }
+    const minutes = Math.floor(duration / 1000 / 60);
+    const seconds = Math.floor(duration / 1000) % 60;
+    const tenths = Math.floor((duration % 1000) / 100);
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}.${tenths}s`;
+    } else {
+        return `${seconds}.${tenths}s`;
+    }
+}
+class NotebookStatusBarController extends Disposable {
+    constructor(_notebookEditor, _itemFactory) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._itemFactory = _itemFactory;
+        this._visibleCells = ( new Map());
+        this._observer = this._register(( new NotebookVisibleCellObserver(this._notebookEditor)));
+        this._register(this._observer.onDidChangeVisibleCells(this._updateVisibleCells, this));
+        this._updateEverything();
+    }
+    _updateEverything() {
+        this._visibleCells.forEach(dispose);
+        this._visibleCells.clear();
+        this._updateVisibleCells({
+            added: this._observer.visibleCells,
+            removed: []
+        });
+    }
+    _updateVisibleCells(e) {
+        const vm = this._notebookEditor.getViewModel();
+        if (!vm) {
+            return;
+        }
+        for (const oldCell of e.removed) {
+            this._visibleCells.get(oldCell.handle)?.dispose();
+            this._visibleCells.delete(oldCell.handle);
+        }
+        for (const newCell of e.added) {
+            this._visibleCells.set(newCell.handle, this._itemFactory(vm, newCell));
+        }
+    }
+    dispose() {
+        super.dispose();
+        this._visibleCells.forEach(dispose);
+        this._visibleCells.clear();
+    }
+}
+let ExecutionStateCellStatusBarContrib = class ExecutionStateCellStatusBarContrib extends Disposable {
+    static {
+        this.id = "workbench.notebook.statusBar.execState";
+    }
+    constructor(notebookEditor, instantiationService) {
+        super();
+        this._register(( new NotebookStatusBarController(
+            notebookEditor,
+            (vm, cell) => instantiationService.createInstance(ExecutionStateCellStatusBarItem, vm, cell)
+        )));
+    }
+};
+ExecutionStateCellStatusBarContrib = ( __decorate([( __param(1, IInstantiationService))], ExecutionStateCellStatusBarContrib));
+registerNotebookContribution(ExecutionStateCellStatusBarContrib.id, ExecutionStateCellStatusBarContrib);
+let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem extends Disposable {
+    static {
+        ExecutionStateCellStatusBarItem_1 = this;
+    }
+    static {
+        this.MIN_SPINNER_TIME = 500;
+    }
+    constructor(_notebookViewModel, _cell, _executionStateService) {
+        super();
+        this._notebookViewModel = _notebookViewModel;
+        this._cell = _cell;
+        this._executionStateService = _executionStateService;
+        this._currentItemIds = [];
+        this._clearExecutingStateTimer = this._register(( new MutableDisposable()));
+        this._update();
+        this._register(this._executionStateService.onDidChangeExecution(e => {
+            if (e.type === NotebookExecutionType.cell && e.affectsCell(this._cell.uri)) {
+                this._update();
+            }
+        }));
+        this._register(this._cell.model.onDidChangeInternalMetadata(() => this._update()));
+    }
+    async _update() {
+        const items = this._getItemsForCell();
+        if (Array.isArray(items)) {
+            this._currentItemIds = this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{
+                handle: this._cell.handle,
+                items
+            }]);
+        }
+    }
+    _getItemsForCell() {
+        const runState = this._executionStateService.getCellExecution(this._cell.uri);
+        if (runState?.state === NotebookCellExecutionState.Executing && typeof this._showedExecutingStateTime !== "number") {
+            this._showedExecutingStateTime = Date.now();
+        } else if (runState?.state !== NotebookCellExecutionState.Executing && typeof this._showedExecutingStateTime === "number") {
+            const timeUntilMin = ExecutionStateCellStatusBarItem_1.MIN_SPINNER_TIME - (Date.now() - this._showedExecutingStateTime);
+            if (timeUntilMin > 0) {
+                if (!this._clearExecutingStateTimer.value) {
+                    this._clearExecutingStateTimer.value = disposableTimeout(() => {
+                        this._showedExecutingStateTime = undefined;
+                        this._clearExecutingStateTimer.clear();
+                        this._update();
+                    }, timeUntilMin);
+                }
+                return undefined;
+            } else {
+                this._showedExecutingStateTime = undefined;
+            }
+        }
+        const items = this._getItemForState(runState, this._cell.internalMetadata);
+        return items;
+    }
+    _getItemForState(runState, internalMetadata) {
+        const state = runState?.state;
+        const {
+            lastRunSuccess
+        } = internalMetadata;
+        if (!state && lastRunSuccess) {
+            return [{
+                text: `$(${successStateIcon.id})`,
+                color: themeColorFromId(cellStatusIconSuccess),
+                tooltip: ( localize(9753, "Success")),
+                alignment: CellStatusbarAlignment.Left,
+                priority: Number.MAX_SAFE_INTEGER
+            }];
+        } else if (!state && lastRunSuccess === false) {
+            return [{
+                text: `$(${errorStateIcon.id})`,
+                color: themeColorFromId(cellStatusIconError),
+                tooltip: ( localize(9754, "Failed")),
+                alignment: CellStatusbarAlignment.Left,
+                priority: Number.MAX_SAFE_INTEGER
+            }];
+        } else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
+            return [{
+                text: `$(${pendingStateIcon.id})`,
+                tooltip: ( localize(9755, "Pending")),
+                alignment: CellStatusbarAlignment.Left,
+                priority: Number.MAX_SAFE_INTEGER
+            }];
+        } else if (state === NotebookCellExecutionState.Executing) {
+            const icon = runState?.didPause ? executingStateIcon : ThemeIcon.modify(executingStateIcon, "spin");
+            return [{
+                text: `$(${icon.id})`,
+                tooltip: ( localize(9756, "Executing")),
+                alignment: CellStatusbarAlignment.Left,
+                priority: Number.MAX_SAFE_INTEGER
+            }];
+        }
+        return [];
+    }
+    dispose() {
+        super.dispose();
+        this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{
+            handle: this._cell.handle,
+            items: []
+        }]);
+    }
+};
+ExecutionStateCellStatusBarItem = ExecutionStateCellStatusBarItem_1 = ( __decorate([( __param(2, INotebookExecutionStateService))], ExecutionStateCellStatusBarItem));
+let TimerCellStatusBarContrib = class TimerCellStatusBarContrib extends Disposable {
+    static {
+        this.id = "workbench.notebook.statusBar.execTimer";
+    }
+    constructor(notebookEditor, instantiationService) {
+        super();
+        this._register(( new NotebookStatusBarController(
+            notebookEditor,
+            (vm, cell) => instantiationService.createInstance(TimerCellStatusBarItem, vm, cell)
+        )));
+    }
+};
+TimerCellStatusBarContrib = ( __decorate([( __param(1, IInstantiationService))], TimerCellStatusBarContrib));
+registerNotebookContribution(TimerCellStatusBarContrib.id, TimerCellStatusBarContrib);
+const UPDATE_TIMER_GRACE_PERIOD = 200;
+let TimerCellStatusBarItem = class TimerCellStatusBarItem extends Disposable {
+    static {
+        TimerCellStatusBarItem_1 = this;
+    }
+    static {
+        this.UPDATE_INTERVAL = 100;
+    }
+    constructor(
+        _notebookViewModel,
+        _cell,
+        _executionStateService,
+        _notebookService,
+        _configurationService
+    ) {
+        super();
+        this._notebookViewModel = _notebookViewModel;
+        this._cell = _cell;
+        this._executionStateService = _executionStateService;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._currentItemIds = [];
+        this._isVerbose = this._configurationService.getValue(NotebookSetting.cellExecutionTimeVerbosity) === "verbose";
+        this._scheduler = this._register(( new RunOnceScheduler(() => this._update(), TimerCellStatusBarItem_1.UPDATE_INTERVAL)));
+        this._update();
+        this._register(this._cell.model.onDidChangeInternalMetadata(() => this._update()));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.cellExecutionTimeVerbosity)) {
+                this._isVerbose = this._configurationService.getValue(NotebookSetting.cellExecutionTimeVerbosity) === "verbose";
+                this._update();
+            }
+        }));
+    }
+    async _update() {
+        let timerItem;
+        const runState = this._executionStateService.getCellExecution(this._cell.uri);
+        const state = runState?.state;
+        const startTime = this._cell.internalMetadata.runStartTime;
+        const adjustment = this._cell.internalMetadata.runStartTimeAdjustment ?? 0;
+        const endTime = this._cell.internalMetadata.runEndTime;
+        if (runState?.didPause) {
+            timerItem = undefined;
+        } else if (state === NotebookCellExecutionState.Executing) {
+            if (typeof startTime === "number") {
+                timerItem = this._getTimeItem(startTime, Date.now(), adjustment);
+                this._scheduler.schedule();
+            }
+        } else if (!state) {
+            if (typeof startTime === "number" && typeof endTime === "number") {
+                const timerDuration = Date.now() - startTime + adjustment;
+                const executionDuration = endTime - startTime;
+                const renderDuration = this._cell.internalMetadata.renderDuration ?? {};
+                timerItem = this._getTimeItem(startTime, endTime, undefined, {
+                    timerDuration,
+                    executionDuration,
+                    renderDuration
+                });
+            }
+        }
+        const items = timerItem ? [timerItem] : [];
+        if (!items.length && !!runState) {
+            if (!this._deferredUpdate) {
+                this._deferredUpdate = disposableTimeout(() => {
+                    this._deferredUpdate = undefined;
+                    this._currentItemIds = this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{
+                        handle: this._cell.handle,
+                        items
+                    }]);
+                }, UPDATE_TIMER_GRACE_PERIOD, this._store);
+            }
+        } else {
+            this._deferredUpdate?.dispose();
+            this._deferredUpdate = undefined;
+            this._currentItemIds = this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{
+                handle: this._cell.handle,
+                items
+            }]);
+        }
+    }
+    _getTimeItem(startTime, endTime, adjustment = 0, runtimeInformation) {
+        const duration = endTime - startTime + adjustment;
+        let tooltip;
+        const lastExecution = ( new Date(endTime)).toLocaleTimeString(language);
+        if (runtimeInformation) {
+            const {
+                renderDuration,
+                executionDuration,
+                timerDuration
+            } = runtimeInformation;
+            let renderTimes = "";
+            for (const key in renderDuration) {
+                const rendererInfo = this._notebookService.getRendererInfo(key);
+                const args = encodeURIComponent(JSON.stringify({
+                    extensionId: rendererInfo?.extensionId.value ?? "",
+                    issueBody: `Auto-generated text from notebook cell performance - Please add an explanation for the performance issue, including cell content if possible.\n` + `The duration for the renderer, ${rendererInfo?.displayName ?? key}, is slower than expected.\n` + `Execution Time: ${formatCellDuration(executionDuration)}\n` + `Renderer Duration: ${formatCellDuration(renderDuration[key])}\n`
+                }));
+                const renderIssueLink = (renderDuration[key] > 200 && executionDuration < 2000) || renderDuration[key] > 1000;
+                const linkText = rendererInfo?.displayName ?? key;
+                const rendererTitle = renderIssueLink ? `[${linkText}](command:workbench.action.openIssueReporter?${args})` : `**${linkText}**`;
+                renderTimes += `- ${rendererTitle} ${formatCellDuration(renderDuration[key])}\n`;
+            }
+            renderTimes += `\n*${( localize(9757, "Use the links above to file an issue using the issue reporter."))}*\n`;
+            tooltip = {
+                value: ( localize(
+                    9758,
+                    "**Last Execution** {0}\n\n**Execution Time** {1}\n\n**Overhead Time** {2}\n\n**Render Times**\n\n{3}",
+                    lastExecution,
+                    formatCellDuration(executionDuration),
+                    formatCellDuration(timerDuration - executionDuration),
+                    renderTimes
+                )),
+                isTrusted: true
+            };
+        }
+        const executionText = this._isVerbose ? ( localize(
+            9759,
+            "Last Execution: {0}, Duration: {1}",
+            lastExecution,
+            formatCellDuration(duration, false)
+        )) : formatCellDuration(duration, false);
+        return {
+            text: executionText,
+            alignment: CellStatusbarAlignment.Left,
+            priority: Number.MAX_SAFE_INTEGER - 5,
+            tooltip
+        };
+    }
+    dispose() {
+        super.dispose();
+        this._deferredUpdate?.dispose();
+        this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{
+            handle: this._cell.handle,
+            items: []
+        }]);
+    }
+};
+TimerCellStatusBarItem = TimerCellStatusBarItem_1 = ( __decorate([( __param(2, INotebookExecutionStateService)), ( __param(3, INotebookService)), ( __param(4, IConfigurationService))], TimerCellStatusBarItem));
+
+export { ExecutionStateCellStatusBarContrib, NotebookStatusBarController, TimerCellStatusBarContrib, formatCellDuration };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/notebookVisibleCellObserver.d.ts

@@ -0,0 +1,18 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICellViewModel, INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+export interface ICellVisibilityChangeEvent {
+    added: ICellViewModel[];
+    removed: ICellViewModel[];
+}
+export declare class NotebookVisibleCellObserver extends Disposable {
+    private readonly _notebookEditor;
+    private readonly _onDidChangeVisibleCells;
+    readonly onDidChangeVisibleCells: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ICellVisibilityChangeEvent>;
+    private readonly _viewModelDisposables;
+    private _visibleCells;
+    get visibleCells(): ICellViewModel[];
+    constructor(_notebookEditor: INotebookEditor);
+    private _onModelChange;
+    protected updateEverything(): void;
+    private _updateVisibleCells;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/notebookVisibleCellObserver.js

@@ -0,0 +1,58 @@
+
+import { diffSets } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { cellRangesToIndexes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRange';
+
+class NotebookVisibleCellObserver extends Disposable {
+    get visibleCells() {
+        return this._visibleCells;
+    }
+    constructor(_notebookEditor) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._onDidChangeVisibleCells = this._register(( new Emitter()));
+        this.onDidChangeVisibleCells = this._onDidChangeVisibleCells.event;
+        this._viewModelDisposables = this._register(( new DisposableStore()));
+        this._visibleCells = [];
+        this._register(
+            this._notebookEditor.onDidChangeVisibleRanges(this._updateVisibleCells, this)
+        );
+        this._register(this._notebookEditor.onDidChangeModel(this._onModelChange, this));
+        this._updateVisibleCells();
+    }
+    _onModelChange() {
+        this._viewModelDisposables.clear();
+        if (this._notebookEditor.hasModel()) {
+            this._viewModelDisposables.add(this._notebookEditor.onDidChangeViewCells(() => this.updateEverything()));
+        }
+        this.updateEverything();
+    }
+    updateEverything() {
+        this._onDidChangeVisibleCells.fire({
+            added: [],
+            removed: Array.from(this._visibleCells)
+        });
+        this._visibleCells = [];
+        this._updateVisibleCells();
+    }
+    _updateVisibleCells() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const newVisibleCells = ( cellRangesToIndexes(this._notebookEditor.visibleRanges).map(index => this._notebookEditor.cellAt(index))).filter(isDefined);
+        const newVisibleHandles = ( new Set(( newVisibleCells.map(cell => cell.handle))));
+        const oldVisibleHandles = ( new Set(( this._visibleCells.map(cell => cell.handle))));
+        const diff = diffSets(oldVisibleHandles, newVisibleHandles);
+        const added = ( diff.added.map(handle => this._notebookEditor.getCellByHandle(handle))).filter(isDefined);
+        const removed = ( diff.removed.map(handle => this._notebookEditor.getCellByHandle(handle))).filter(isDefined);
+        this._visibleCells = newVisibleCells;
+        this._onDidChangeVisibleCells.fire({
+            added,
+            removed
+        });
+    }
+}
+
+export { NotebookVisibleCellObserver };