@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common 20.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatZoneWidget.js

@@ -0,0 +1,276 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { addDisposableListener, Dimension } 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 { toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { StableEditorBottomScrollState } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/stableEditorScroll';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { ScrollType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon';
+import { ZoneWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/zoneWidget/browser/zoneWidget';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isResponseVM } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, MENU_INLINE_CHAT_SIDE, MENU_INLINE_CHAT_WIDGET_SECONDARY, ACTION_REGENERATE_RESPONSE, ACTION_TOGGLE_DIFF, ACTION_REPORT_ISSUE, MENU_INLINE_CHAT_WIDGET_STATUS } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { EditorBasedInlineChatWidget } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatWidget';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var InlineChatZoneWidget_1;
+let InlineChatZoneWidget = class InlineChatZoneWidget extends ZoneWidget {
+    static { InlineChatZoneWidget_1 = this; }
+    static { this._options = {
+        showFrame: true,
+        frameWidth: 1,
+        isResizeable: true,
+        showArrow: false,
+        isAccessible: true,
+        className: 'inline-chat-widget',
+        keepEditorSelection: true,
+        showInHiddenAreas: true,
+        ordinal: 50000,
+    }; }
+    constructor(location, options, editors, _instaService, _logService, contextKeyService) {
+        super(editors.editor, InlineChatZoneWidget_1._options);
+        this._instaService = _instaService;
+        this._logService = _logService;
+        this._scrollUp = this._disposables.add(( new ScrollUpState(this.editor)));
+        this.notebookEditor = editors.notebookEditor;
+        this._ctxCursorPosition = CTX_INLINE_CHAT_OUTER_CURSOR_POSITION.bindTo(contextKeyService);
+        this._disposables.add(toDisposable(() => {
+            this._ctxCursorPosition.reset();
+        }));
+        this.widget = this._instaService.createInstance(EditorBasedInlineChatWidget, location, this.editor, {
+            statusMenuId: {
+                menu: MENU_INLINE_CHAT_WIDGET_STATUS,
+                options: {
+                    buttonConfigProvider: (action, index) => {
+                        const isSecondary = index > 0;
+                        if (( ( new Set([ACTION_REGENERATE_RESPONSE, ACTION_TOGGLE_DIFF, ACTION_REPORT_ISSUE])).has(action.id))) {
+                            return { isSecondary, showIcon: true, showLabel: false };
+                        }
+                        else {
+                            return { isSecondary };
+                        }
+                    }
+                }
+            },
+            secondaryMenuId: MENU_INLINE_CHAT_WIDGET_SECONDARY,
+            inZoneWidget: true,
+            chatWidgetViewOptions: {
+                menus: {
+                    telemetrySource: 'interactiveEditorWidget-toolbar',
+                    inputSideToolbar: MENU_INLINE_CHAT_SIDE
+                },
+                ...options,
+                rendererOptions: {
+                    renderTextEditsAsSummary: (uri) => {
+                        return isEqual(uri, editors.editor.getModel()?.uri);
+                    },
+                    renderDetectedCommandsWithRequest: true,
+                    ...options?.rendererOptions
+                },
+            }
+        });
+        this._disposables.add(this.widget);
+        let revealFn;
+        this._disposables.add(this.widget.chatWidget.onWillMaybeChangeHeight(() => {
+            if (this.position) {
+                revealFn = this._createZoneAndScrollRestoreFn(this.position);
+            }
+        }));
+        this._disposables.add(this.widget.onDidChangeHeight(() => {
+            if (this.position && !this._usesResizeHeight) {
+                revealFn ??= this._createZoneAndScrollRestoreFn(this.position);
+                const height = this._computeHeight();
+                this._relayout(height.linesValue);
+                revealFn?.();
+                revealFn = undefined;
+            }
+        }));
+        this.create();
+        this._disposables.add(autorun(r => {
+            const isBusy = this.widget.requestInProgress.read(r);
+            this.domNode.firstElementChild?.classList.toggle('busy', isBusy);
+        }));
+        this._disposables.add(addDisposableListener(this.domNode, 'click', e => {
+            if (!this.editor.hasWidgetFocus() && !this.widget.hasFocus()) {
+                this.editor.focus();
+            }
+        }, true));
+        const updateCursorIsAboveContextKey = () => {
+            if (!this.position || !this.editor.hasModel()) {
+                this._ctxCursorPosition.reset();
+            }
+            else if (this.position.lineNumber === this.editor.getPosition().lineNumber) {
+                this._ctxCursorPosition.set('above');
+            }
+            else if (this.position.lineNumber + 1 === this.editor.getPosition().lineNumber) {
+                this._ctxCursorPosition.set('below');
+            }
+            else {
+                this._ctxCursorPosition.reset();
+            }
+        };
+        this._disposables.add(this.editor.onDidChangeCursorPosition(e => updateCursorIsAboveContextKey()));
+        this._disposables.add(this.editor.onDidFocusEditorText(e => updateCursorIsAboveContextKey()));
+        updateCursorIsAboveContextKey();
+    }
+    _fillContainer(container) {
+        container.style.setProperty('--vscode-inlineChat-background', 'var(--vscode-editor-background)');
+        container.appendChild(this.widget.domNode);
+    }
+    _doLayout(heightInPixel) {
+        this._updatePadding();
+        const info = this.editor.getLayoutInfo();
+        const width = info.contentWidth - info.verticalScrollbarWidth;
+        this._dimension = ( new Dimension(width, heightInPixel));
+        this.widget.layout(this._dimension);
+    }
+    _computeHeight() {
+        const chatContentHeight = this.widget.contentHeight;
+        const editorHeight = this.notebookEditor?.getLayoutInfo().height ?? this.editor.getLayoutInfo().height;
+        const contentHeight = this._decoratingElementsHeight() + Math.min(chatContentHeight, Math.max(this.widget.minHeight, editorHeight * 0.42));
+        const heightInLines = contentHeight / this.editor.getOption(EditorOption.lineHeight);
+        return { linesValue: heightInLines, pixelsValue: contentHeight };
+    }
+    _getResizeBounds() {
+        const lineHeight = this.editor.getOption(EditorOption.lineHeight);
+        const decoHeight = this._decoratingElementsHeight();
+        const minHeightPx = decoHeight + this.widget.minHeight;
+        const maxHeightPx = decoHeight + this.widget.contentHeight;
+        return {
+            minLines: minHeightPx / lineHeight,
+            maxLines: maxHeightPx / lineHeight
+        };
+    }
+    _onWidth(_widthInPixel) {
+        if (this._dimension) {
+            this._doLayout(this._dimension.height);
+        }
+    }
+    show(position) {
+        assertType(this.container);
+        this._updatePadding();
+        const revealZone = this._createZoneAndScrollRestoreFn(position);
+        super.show(position, this._computeHeight().linesValue);
+        this.widget.chatWidget.setVisible(true);
+        this.widget.focus();
+        revealZone();
+        this._scrollUp.enable();
+    }
+    _updatePadding() {
+        assertType(this.container);
+        const info = this.editor.getLayoutInfo();
+        const marginWithoutIndentation = info.glyphMarginWidth + info.lineNumbersWidth + info.decorationsWidth;
+        this.container.style.paddingLeft = `${marginWithoutIndentation}px`;
+    }
+    reveal(position) {
+        const stickyScroll = this.editor.getOption(EditorOption.stickyScroll);
+        const magicValue = stickyScroll.enabled ? stickyScroll.maxLineCount : 0;
+        this.editor.revealLines(position.lineNumber + magicValue, position.lineNumber + magicValue, ScrollType.Immediate);
+        this._scrollUp.reset();
+        this.updatePositionAndHeight(position);
+    }
+    updatePositionAndHeight(position) {
+        const revealZone = this._createZoneAndScrollRestoreFn(position);
+        super.updatePositionAndHeight(position, !this._usesResizeHeight ? this._computeHeight().linesValue : undefined);
+        revealZone();
+    }
+    _createZoneAndScrollRestoreFn(position) {
+        const scrollState = StableEditorBottomScrollState.capture(this.editor);
+        const lineNumber = position.lineNumber <= 1 ? 1 : 1 + position.lineNumber;
+        const scrollTop = this.editor.getScrollTop();
+        const lineTop = this.editor.getTopForLineNumber(lineNumber);
+        const zoneTop = lineTop - this._computeHeight().pixelsValue;
+        const hasResponse = this.widget.chatWidget.viewModel?.getItems().find(candidate => {
+            return isResponseVM(candidate) && candidate.response.value.length > 0;
+        });
+        if (hasResponse && zoneTop < scrollTop || this._scrollUp.didScrollUpOrDown) {
+            return this._scrollUp.runIgnored(() => {
+                scrollState.restore(this.editor);
+            });
+        }
+        return this._scrollUp.runIgnored(() => {
+            scrollState.restore(this.editor);
+            const scrollTop = this.editor.getScrollTop();
+            const lineTop = this.editor.getTopForLineNumber(lineNumber);
+            const zoneTop = lineTop - this._computeHeight().pixelsValue;
+            const editorHeight = this.editor.getLayoutInfo().height;
+            const lineBottom = this.editor.getBottomForLineNumber(lineNumber);
+            let newScrollTop = zoneTop;
+            let forceScrollTop = false;
+            if (lineBottom >= (scrollTop + editorHeight)) {
+                newScrollTop = lineBottom - editorHeight;
+                forceScrollTop = true;
+            }
+            if (newScrollTop < scrollTop || forceScrollTop) {
+                this._logService.trace('[IE] REVEAL zone', { zoneTop, lineTop, lineBottom, scrollTop, newScrollTop, forceScrollTop });
+                this.editor.setScrollTop(newScrollTop, ScrollType.Immediate);
+            }
+        });
+    }
+    revealRange(range, isLastLine) {
+    }
+    hide() {
+        const scrollState = StableEditorBottomScrollState.capture(this.editor);
+        this._scrollUp.disable();
+        this._ctxCursorPosition.reset();
+        this.widget.reset();
+        this.widget.chatWidget.setVisible(false);
+        super.hide();
+        status(( localize(7693, 'Closed inline chat widget')));
+        scrollState.restore(this.editor);
+    }
+};
+InlineChatZoneWidget = InlineChatZoneWidget_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IContextKeyService))
+], InlineChatZoneWidget));
+class ScrollUpState {
+    constructor(_editor) {
+        this._editor = _editor;
+        this._ignoreEvents = false;
+        this._listener = ( new MutableDisposable());
+    }
+    dispose() {
+        this._listener.dispose();
+    }
+    reset() {
+        this._didScrollUpOrDown = undefined;
+    }
+    enable() {
+        this._didScrollUpOrDown = undefined;
+        this._listener.value = this._editor.onDidScrollChange(e => {
+            if (!e.scrollTopChanged || this._ignoreEvents) {
+                return;
+            }
+            this._listener.clear();
+            this._didScrollUpOrDown = true;
+        });
+    }
+    disable() {
+        this._listener.clear();
+        this._didScrollUpOrDown = undefined;
+    }
+    runIgnored(callback) {
+        return () => {
+            this._ignoreEvents = true;
+            try {
+                return callback();
+            }
+            finally {
+                this._ignoreEvents = false;
+            }
+        };
+    }
+    get didScrollUpOrDown() {
+        return this._didScrollUpOrDown;
+    }
+}
+
+export { InlineChatZoneWidget };

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-670aae94-7f88-54d7-90ea-6fcbef423557-common/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,318 @@
+
+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-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { cellStatusIconSuccess, cellStatusIconError } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
+import { successStateIcon, errorStateIcon, pendingStateIcon, executingStateIcon } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/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-e28ac690-06d5-5ee9-92d1-02df70296354-common/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(8544, "Success")),
+                    alignment: CellStatusbarAlignment.Left,
+                    priority: Number.MAX_SAFE_INTEGER
+                }];
+        }
+        else if (!state && lastRunSuccess === false) {
+            return [{
+                    text: `$(${errorStateIcon.id})`,
+                    color: themeColorFromId(cellStatusIconError),
+                    tooltip: ( localize(8545, "Failed")),
+                    alignment: CellStatusbarAlignment.Left,
+                    priority: Number.MAX_SAFE_INTEGER
+                }];
+        }
+        else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
+            return [{
+                    text: `$(${pendingStateIcon.id})`,
+                    tooltip: ( localize(8546, "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(8547, "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. The duration for the renderer, ${rendererInfo?.displayName ?? key}, is slower than expected.\n` +
+                        `Execution Time: ${formatCellDuration(executionDuration)}\n` +
+                        `Renderer Duration: ${formatCellDuration(renderDuration[key])}\n`
+                }));
+                renderTimes += `- [${rendererInfo?.displayName ?? key}](command:workbench.action.openIssueReporter?${args}) ${formatCellDuration(renderDuration[key])}\n`;
+            }
+            renderTimes += `\n*${( localize(8548, "Use the links above to file an issue using the issue reporter."))}*\n`;
+            tooltip = {
+                value: ( localize(
+                    8549,
+                    "**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(
+            8550,
+            "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-670aae94-7f88-54d7-90ea-6fcbef423557-common/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;
+}