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

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

@@ -0,0 +1,109 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Throttler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotebookVisibleCellObserver } from './notebookVisibleCellObserver.js';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+
+let ContributedStatusBarItemController = class ContributedStatusBarItemController extends Disposable {
+    static { this.id = 'workbench.notebook.statusBar.contributed'; }
+    constructor(_notebookEditor, _notebookCellStatusBarService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._notebookCellStatusBarService = _notebookCellStatusBarService;
+        this._visibleCells = ( new Map());
+        this._observer = this._register(( new NotebookVisibleCellObserver(this._notebookEditor)));
+        this._register(this._observer.onDidChangeVisibleCells(this._updateVisibleCells, this));
+        this._updateEverything();
+        this._register(this._notebookCellStatusBarService.onDidChangeProviders(this._updateEverything, this));
+        this._register(this._notebookCellStatusBarService.onDidChangeItems(this._updateEverything, this));
+    }
+    _updateEverything() {
+        const newCells = this._observer.visibleCells.filter(cell => !( this._visibleCells.has(cell.handle)));
+        const visibleCellHandles = ( new Set(( this._observer.visibleCells.map(item => item.handle))));
+        const currentCellHandles = Array.from(( this._visibleCells.keys()));
+        const removedCells = currentCellHandles.filter(handle => !( visibleCellHandles.has(handle)));
+        const itemsToUpdate = currentCellHandles.filter(handle => ( visibleCellHandles.has(handle)));
+        this._updateVisibleCells({ added: newCells, removed: ( removedCells.map(handle => ({ handle }))) });
+        itemsToUpdate.forEach(handle => this._visibleCells.get(handle)?.update());
+    }
+    _updateVisibleCells(e) {
+        const vm = this._notebookEditor.getViewModel();
+        if (!vm) {
+            return;
+        }
+        for (const newCell of e.added) {
+            const helper = ( new CellStatusBarHelper(vm, newCell, this._notebookCellStatusBarService));
+            this._visibleCells.set(newCell.handle, helper);
+        }
+        for (const oldCell of e.removed) {
+            this._visibleCells.get(oldCell.handle)?.dispose();
+            this._visibleCells.delete(oldCell.handle);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this._visibleCells.forEach(cell => cell.dispose());
+        this._visibleCells.clear();
+    }
+};
+ContributedStatusBarItemController = ( __decorate([
+    ( __param(1, INotebookCellStatusBarService))
+], ContributedStatusBarItemController));
+class CellStatusBarHelper extends Disposable {
+    constructor(_notebookViewModel, _cell, _notebookCellStatusBarService) {
+        super();
+        this._notebookViewModel = _notebookViewModel;
+        this._cell = _cell;
+        this._notebookCellStatusBarService = _notebookCellStatusBarService;
+        this._currentItemIds = [];
+        this._currentItemLists = [];
+        this._isDisposed = false;
+        this._updateThrottler = this._register(( new Throttler()));
+        this._register(toDisposable(() => this._activeToken?.dispose(true)));
+        this._updateSoon();
+        this._register(this._cell.model.onDidChangeContent(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeLanguage(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeMetadata(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeInternalMetadata(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeOutputs(() => this._updateSoon()));
+    }
+    update() {
+        this._updateSoon();
+    }
+    _updateSoon() {
+        setTimeout(() => {
+            if (!this._isDisposed) {
+                this._updateThrottler.queue(() => this._update());
+            }
+        }, 0);
+    }
+    async _update() {
+        const cellIndex = this._notebookViewModel.getCellIndex(this._cell);
+        const docUri = this._notebookViewModel.notebookDocument.uri;
+        const viewType = this._notebookViewModel.notebookDocument.viewType;
+        this._activeToken?.dispose(true);
+        const tokenSource = this._activeToken = ( new CancellationTokenSource());
+        const itemLists = await this._notebookCellStatusBarService.getStatusBarItemsForCell(docUri, cellIndex, viewType, tokenSource.token);
+        if (tokenSource.token.isCancellationRequested) {
+            itemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+            return;
+        }
+        const items = ( itemLists.map(itemList => itemList.items)).flat();
+        const newIds = this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{ handle: this._cell.handle, items }]);
+        this._currentItemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+        this._currentItemLists = itemLists;
+        this._currentItemIds = newIds;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+        this._activeToken?.dispose(true);
+        this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{ handle: this._cell.handle, items: [] }]);
+        this._currentItemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+    }
+}
+registerNotebookContribution(ContributedStatusBarItemController.id, ContributedStatusBarItemController);
+
+export { ContributedStatusBarItemController };

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

@@ -0,0 +1,319 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { disposableTimeout, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { NotebookVisibleCellObserver } from './notebookVisibleCellObserver.js';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { cellStatusIconSuccess, cellStatusIconError } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
+import { successStateIcon, errorStateIcon, pendingStateIcon, executingStateIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { NotebookCellExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NotebookExecutionType, INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+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: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                        'notebook.cell.status.success',
+                        "Success"
+                    )),
+                    alignment: 1 ,
+                    priority: Number.MAX_SAFE_INTEGER
+                }];
+        }
+        else if (!state && lastRunSuccess === false) {
+            return [{
+                    text: `$(${errorStateIcon.id})`,
+                    color: themeColorFromId(cellStatusIconError),
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                        'notebook.cell.status.failed',
+                        "Failed"
+                    )),
+                    alignment: 1 ,
+                    priority: Number.MAX_SAFE_INTEGER
+                }];
+        }
+        else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
+            return [{
+                    text: `$(${pendingStateIcon.id})`,
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                        'notebook.cell.status.pending',
+                        "Pending"
+                    )),
+                    alignment: 1 ,
+                    priority: Number.MAX_SAFE_INTEGER
+                }];
+        }
+        else if (state === NotebookCellExecutionState.Executing) {
+            const icon = runState?.didPause ?
+                executingStateIcon :
+                ThemeIcon.modify(executingStateIcon, 'spin');
+            return [{
+                    text: `$(${icon.id})`,
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                        'notebook.cell.status.executing',
+                        "Executing"
+                    )),
+                    alignment: 1 ,
+                    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) {
+        super();
+        this._notebookViewModel = _notebookViewModel;
+        this._cell = _cell;
+        this._executionStateService = _executionStateService;
+        this._notebookService = _notebookService;
+        this._currentItemIds = [];
+        this._scheduler = this._register(( new RunOnceScheduler(() => this._update(), TimerCellStatusBarItem_1.UPDATE_INTERVAL)));
+        this._update();
+        this._register(this._cell.model.onDidChangeInternalMetadata(() => 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);
+            }
+        }
+        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;
+        if (runtimeInformation) {
+            const lastExecution = ( new Date(endTime)).toLocaleTimeString(language);
+            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*${( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                'notebook.cell.statusBar.timerTooltip.reportIssueFootnote',
+                "Use the links above to file an issue using the issue reporter."
+            ))}*\n`;
+            tooltip = {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController',
+                    'notebook.cell.statusBar.timerTooltip',
+                    "**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
+            };
+        }
+        return {
+            text: formatCellDuration(duration, false),
+            alignment: 1 ,
+            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))
+], TimerCellStatusBarItem));
+
+export { ExecutionStateCellStatusBarContrib, NotebookStatusBarController, TimerCellStatusBarContrib, formatCellDuration };

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

@@ -0,0 +1,58 @@
+import { diffSets } from 'monaco-editor/esm/vs/base/common/collections.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { cellRangesToIndexes } from 'vscode/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 };

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

@@ -0,0 +1,173 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { CHANGE_CELL_LANGUAGE, DETECT_CELL_LANGUAGE } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { ILanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
+
+let CellStatusBarLanguagePickerProvider = class CellStatusBarLanguagePickerProvider {
+    constructor(_notebookService, _languageService) {
+        this._notebookService = _notebookService;
+        this._languageService = _languageService;
+        this.viewType = '*';
+    }
+    async provideCellStatusBarItems(uri, index, _token) {
+        const doc = this._notebookService.getNotebookTextModel(uri);
+        const cell = doc?.cells[index];
+        if (!cell) {
+            return;
+        }
+        const statusBarItems = [];
+        let displayLanguage = cell.language;
+        if (cell.cellKind === CellKind.Markup) {
+            displayLanguage = 'markdown';
+        }
+        else {
+            const registeredId = this._languageService.getLanguageIdByLanguageName(cell.language);
+            if (registeredId) {
+                displayLanguage = this._languageService.getLanguageName(displayLanguage) ?? displayLanguage;
+            }
+            else {
+                const searchTooltip = ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                    'notebook.cell.status.searchLanguageExtensions',
+                    "Unknown cell language. Click to search for '{0}' extensions",
+                    cell.language
+                ));
+                statusBarItems.push({
+                    text: `$(dialog-warning)`,
+                    command: { id: 'workbench.extensions.search', arguments: [`@tag:${cell.language}`], title: 'Search Extensions' },
+                    tooltip: searchTooltip,
+                    alignment: 2 ,
+                    priority: -Number.MAX_SAFE_INTEGER + 1
+                });
+            }
+        }
+        statusBarItems.push({
+            text: displayLanguage,
+            command: CHANGE_CELL_LANGUAGE,
+            tooltip: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                'notebook.cell.status.language',
+                "Select Cell Language Mode"
+            )),
+            alignment: 2 ,
+            priority: -Number.MAX_SAFE_INTEGER
+        });
+        return {
+            items: statusBarItems
+        };
+    }
+};
+CellStatusBarLanguagePickerProvider = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, ILanguageService))
+], CellStatusBarLanguagePickerProvider));
+let CellStatusBarLanguageDetectionProvider = class CellStatusBarLanguageDetectionProvider {
+    constructor(_notebookService, _notebookKernelService, _languageService, _configurationService, _languageDetectionService, _keybindingService) {
+        this._notebookService = _notebookService;
+        this._notebookKernelService = _notebookKernelService;
+        this._languageService = _languageService;
+        this._configurationService = _configurationService;
+        this._languageDetectionService = _languageDetectionService;
+        this._keybindingService = _keybindingService;
+        this.viewType = '*';
+        this.cache = ( new ResourceMap());
+    }
+    async provideCellStatusBarItems(uri, index, token) {
+        const doc = this._notebookService.getNotebookTextModel(uri);
+        const cell = doc?.cells[index];
+        if (!cell) {
+            return;
+        }
+        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
+        const enabled = typeof enablementConfig === 'object' && enablementConfig?.notebookEditors;
+        if (!enabled) {
+            return;
+        }
+        const cellUri = cell.uri;
+        const contentVersion = cell.textModel?.getVersionId();
+        if (!contentVersion) {
+            return;
+        }
+        const currentLanguageId = cell.cellKind === CellKind.Markup ?
+            'markdown' :
+            (this._languageService.getLanguageIdByLanguageName(cell.language) || cell.language);
+        if (!( this.cache.has(cellUri))) {
+            this.cache.set(cellUri, {
+                cellLanguage: currentLanguageId,
+                updateTimestamp: 0,
+                contentVersion: 1,
+            });
+        }
+        const cached = this.cache.get(cellUri);
+        if (cached.cellLanguage !== currentLanguageId || (cached.updateTimestamp < Date.now() - 1000 && cached.contentVersion !== contentVersion)) {
+            cached.updateTimestamp = Date.now();
+            cached.cellLanguage = currentLanguageId;
+            cached.contentVersion = contentVersion;
+            const kernel = this._notebookKernelService.getSelectedOrSuggestedKernel(doc);
+            if (kernel) {
+                const supportedLangs = [...kernel.supportedLanguages, 'markdown'];
+                cached.guess = await this._languageDetectionService.detectLanguage(cell.uri, supportedLangs);
+            }
+        }
+        const items = [];
+        if (cached.guess && currentLanguageId !== cached.guess) {
+            const detectedName = this._languageService.getLanguageName(cached.guess) || cached.guess;
+            let tooltip = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                'notebook.cell.status.autoDetectLanguage',
+                "Accept Detected Language: {0}",
+                detectedName
+            ));
+            const keybinding = this._keybindingService.lookupKeybinding(DETECT_CELL_LANGUAGE);
+            const label = keybinding?.getLabel();
+            if (label) {
+                tooltip += ` (${label})`;
+            }
+            items.push({
+                text: '$(lightbulb-autofix)',
+                command: DETECT_CELL_LANGUAGE,
+                tooltip,
+                alignment: 2 ,
+                priority: -Number.MAX_SAFE_INTEGER + 1
+            });
+        }
+        return { items };
+    }
+};
+CellStatusBarLanguageDetectionProvider = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, INotebookKernelService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ILanguageDetectionService)),
+    ( __param(5, IKeybindingService))
+], CellStatusBarLanguageDetectionProvider));
+let BuiltinCellStatusBarProviders = class BuiltinCellStatusBarProviders extends Disposable {
+    constructor(instantiationService, notebookCellStatusBarService) {
+        super();
+        const builtinProviders = [
+            CellStatusBarLanguagePickerProvider,
+            CellStatusBarLanguageDetectionProvider,
+        ];
+        builtinProviders.forEach(p => {
+            this._register(notebookCellStatusBarService.registerCellStatusBarItemProvider(instantiationService.createInstance(p)));
+        });
+    }
+};
+BuiltinCellStatusBarProviders = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookCellStatusBarService))
+], BuiltinCellStatusBarProviders));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinCellStatusBarProviders, 3 );