@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

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

@@ -15,7 +15,9 @@ import { NotebookExecutionType } from '@codingame/monaco-vscode-api/vscode/vs/wo
 import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 
 let PausedCellDecorationContribution = class PausedCellDecorationContribution extends Disposable {
-    static { this.id = 'workbench.notebook.debug.pausedCellDecorations'; }
+    static {
+        this.id = "workbench.notebook.debug.pausedCellDecorations";
+    }
     constructor(_notebookEditor, _debugService, _notebookExecutionStateService) {
         super();
         this._notebookEditor = _notebookEditor;
@@ -25,8 +27,12 @@ let PausedCellDecorationContribution = class PausedCellDecorationContribution ex
         this._currentOtherDecorations = [];
         this._executingCellDecorations = [];
         const delayer = this._register(( new Delayer(200)));
-        this._register(_debugService.getModel().onDidChangeCallStack(() => this.updateExecutionDecorations()));
-        this._register(_debugService.getViewModel().onDidFocusStackFrame(() => this.updateExecutionDecorations()));
+        this._register(
+            _debugService.getModel().onDidChangeCallStack(() => this.updateExecutionDecorations())
+        );
+        this._register(
+            _debugService.getViewModel().onDidFocusStackFrame(() => this.updateExecutionDecorations())
+        );
         this._register(_notebookExecutionStateService.onDidChangeExecution(e => {
             if (e.type === NotebookExecutionType.cell && this._notebookEditor.textModel && e.affectsNotebook(this._notebookEditor.textModel.uri)) {
                 delayer.trigger(() => this.updateExecutionDecorations());
@@ -34,15 +40,16 @@ let PausedCellDecorationContribution = class PausedCellDecorationContribution ex
         }));
     }
     updateExecutionDecorations() {
-        const exes = this._notebookEditor.textModel ?
-            this._notebookExecutionStateService.getCellExecutionsByHandleForNotebook(this._notebookEditor.textModel.uri)
-            : undefined;
+        const exes = this._notebookEditor.textModel ? this._notebookExecutionStateService.getCellExecutionsByHandleForNotebook(this._notebookEditor.textModel.uri) : undefined;
         const topFrameCellsAndRanges = [];
         let focusedFrameCellAndRange = undefined;
-        const getNotebookCellAndRange = (sf) => {
+        const getNotebookCellAndRange = sf => {
             const parsed = CellUri.parse(sf.source.uri);
             if (parsed && ( parsed.notebook.toString()) === this._notebookEditor.textModel?.uri.toString()) {
-                return { handle: parsed.handle, range: sf.range };
+                return {
+                    handle: parsed.handle,
+                    range: sf.range
+                };
             }
             return undefined;
         };
@@ -61,25 +68,25 @@ let PausedCellDecorationContribution = class PausedCellDecorationContribution ex
         const focusedFrame = this._debugService.getViewModel().focusedStackFrame;
         if (focusedFrame && focusedFrame.thread.stopped) {
             const thisFocusedFrameCellAndRange = getNotebookCellAndRange(focusedFrame);
-            if (thisFocusedFrameCellAndRange &&
-                !( topFrameCellsAndRanges.some(
-                    topFrame => topFrame.handle === thisFocusedFrameCellAndRange?.handle && Range.equalsRange(topFrame.range, thisFocusedFrameCellAndRange?.range)
-                ))) {
+            if (thisFocusedFrameCellAndRange && !( topFrameCellsAndRanges.some(
+                topFrame => topFrame.handle === thisFocusedFrameCellAndRange?.handle && Range.equalsRange(topFrame.range, thisFocusedFrameCellAndRange?.range)
+            ))) {
                 focusedFrameCellAndRange = thisFocusedFrameCellAndRange;
                 exes?.delete(focusedFrameCellAndRange.handle);
             }
         }
         this.setTopFrameDecoration(topFrameCellsAndRanges);
         this.setFocusedFrameDecoration(focusedFrameCellAndRange);
-        const exeHandles = exes ?
-            ( Array.from(exes.entries())
-                .filter(([_, exe]) => exe.state === NotebookCellExecutionState.Executing)
-                .map(([handle]) => handle))
-            : [];
+        const exeHandles = exes ? ( Array.from(exes.entries()).filter(([_, exe]) => exe.state === NotebookCellExecutionState.Executing).map(([handle]) => handle)) : [];
         this.setExecutingCellDecorations(exeHandles);
     }
     setTopFrameDecoration(handlesAndRanges) {
-        const newDecorations = ( handlesAndRanges.map(({ handle, range }) => {
+        const newDecorations = ( handlesAndRanges.map((
+            {
+                handle,
+                range
+            }
+        ) => {
             const options = {
                 overviewRuler: {
                     color: topStackFrameColor,
@@ -107,9 +114,9 @@ let PausedCellDecorationContribution = class PausedCellDecorationContribution ex
                 }
             };
             newDecorations = [{
-                    handle: focusedFrameCellAndRange.handle,
-                    options
-                }];
+                handle: focusedFrameCellAndRange.handle,
+                options
+            }];
         }
         this._currentOtherDecorations = this._notebookEditor.deltaCellDecorations(this._currentOtherDecorations, newDecorations);
     }
@@ -131,48 +138,49 @@ let PausedCellDecorationContribution = class PausedCellDecorationContribution ex
         this._executingCellDecorations = this._notebookEditor.deltaCellDecorations(this._executingCellDecorations, newDecorations);
     }
 };
-PausedCellDecorationContribution = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, INotebookExecutionStateService))
-], PausedCellDecorationContribution));
+PausedCellDecorationContribution = ( __decorate([( __param(1, IDebugService)), ( __param(2, INotebookExecutionStateService))], PausedCellDecorationContribution));
 registerNotebookContribution(PausedCellDecorationContribution.id, PausedCellDecorationContribution);
 let NotebookBreakpointDecorations = class NotebookBreakpointDecorations extends Disposable {
-    static { this.id = 'workbench.notebook.debug.notebookBreakpointDecorations'; }
+    static {
+        this.id = "workbench.notebook.debug.notebookBreakpointDecorations";
+    }
     constructor(_notebookEditor, _debugService, _configService) {
         super();
         this._notebookEditor = _notebookEditor;
         this._debugService = _debugService;
         this._configService = _configService;
         this._currentDecorations = [];
-        this._register(_debugService.getModel().onDidChangeBreakpoints(() => this.updateDecorations()));
-        this._register(_configService.onDidChangeConfiguration(e => e.affectsConfiguration('debug.showBreakpointsInOverviewRuler') && this.updateDecorations()));
+        this._register(
+            _debugService.getModel().onDidChangeBreakpoints(() => this.updateDecorations())
+        );
+        this._register(_configService.onDidChangeConfiguration(
+            e => e.affectsConfiguration("debug.showBreakpointsInOverviewRuler") && this.updateDecorations()
+        ));
     }
     updateDecorations() {
-        const enabled = this._configService.getValue('debug.showBreakpointsInOverviewRuler');
-        const newDecorations = enabled ?
-            ( this._debugService.getModel().getBreakpoints().map(breakpoint => {
-                const parsed = CellUri.parse(breakpoint.uri);
-                if (!parsed || ( parsed.notebook.toString()) !== ( this._notebookEditor.textModel.uri.toString())) {
-                    return null;
+        const enabled = this._configService.getValue("debug.showBreakpointsInOverviewRuler");
+        const newDecorations = enabled ? ( this._debugService.getModel().getBreakpoints().map(breakpoint => {
+            const parsed = CellUri.parse(breakpoint.uri);
+            if (!parsed || ( parsed.notebook.toString()) !== ( this._notebookEditor.textModel.uri.toString())) {
+                return null;
+            }
+            const options = {
+                overviewRuler: {
+                    color: debugIconBreakpointForeground,
+                    includeOutput: false,
+                    modelRanges: [( new Range(breakpoint.lineNumber, 0, breakpoint.lineNumber, 0))],
+                    position: NotebookOverviewRulerLane.Left
                 }
-                const options = {
-                    overviewRuler: {
-                        color: debugIconBreakpointForeground,
-                        includeOutput: false,
-                        modelRanges: [( new Range(breakpoint.lineNumber, 0, breakpoint.lineNumber, 0))],
-                        position: NotebookOverviewRulerLane.Left
-                    }
-                };
-                return { handle: parsed.handle, options };
-            })).filter(x => !!x)
-            : [];
+            };
+            return {
+                handle: parsed.handle,
+                options
+            };
+        })).filter(x => !!x) : [];
         this._currentDecorations = this._notebookEditor.deltaCellDecorations(this._currentDecorations, newDecorations);
     }
 };
-NotebookBreakpointDecorations = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IConfigurationService))
-], NotebookBreakpointDecorations));
+NotebookBreakpointDecorations = ( __decorate([( __param(1, IDebugService)), ( __param(2, IConfigurationService))], NotebookBreakpointDecorations));
 registerNotebookContribution(NotebookBreakpointDecorations.id, NotebookBreakpointDecorations);
 
 export { NotebookBreakpointDecorations, PausedCellDecorationContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/editorHint/emptyCellEditorHint.js

@@ -11,9 +11,24 @@ import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 
 let EmptyCellEditorHintContribution = class EmptyCellEditorHintContribution extends EmptyTextEditorHintContribution {
-    static { this.CONTRIB_ID = 'notebook.editor.contrib.emptyCellEditorHint'; }
-    constructor(editor, _editorService, configurationService, inlineChatSessionService, chatAgentService, instantiationService) {
-        super(editor, configurationService, inlineChatSessionService, chatAgentService, instantiationService);
+    static {
+        this.CONTRIB_ID = "notebook.editor.contrib.emptyCellEditorHint";
+    }
+    constructor(
+        editor,
+        _editorService,
+        configurationService,
+        inlineChatSessionService,
+        chatAgentService,
+        instantiationService
+    ) {
+        super(
+            editor,
+            configurationService,
+            inlineChatSessionService,
+            chatAgentService,
+            instantiationService
+        );
         this._editorService = _editorService;
         const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
         if (!activeEditor) {
@@ -45,13 +60,11 @@ let EmptyCellEditorHintContribution = class EmptyCellEditorHintContribution exte
         return true;
     }
 };
-EmptyCellEditorHintContribution = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IInlineChatSessionService)),
-    ( __param(4, IChatAgentService)),
-    ( __param(5, IInstantiationService))
-], EmptyCellEditorHintContribution));
-registerEditorContribution(EmptyCellEditorHintContribution.CONTRIB_ID, EmptyCellEditorHintContribution, EditorContributionInstantiation.Eager);
+EmptyCellEditorHintContribution = ( __decorate([( __param(1, IEditorService)), ( __param(2, IConfigurationService)), ( __param(3, IInlineChatSessionService)), ( __param(4, IChatAgentService)), ( __param(5, IInstantiationService))], EmptyCellEditorHintContribution));
+registerEditorContribution(
+    EmptyCellEditorHintContribution.CONTRIB_ID,
+    EmptyCellEditorHintContribution,
+    EditorContributionInstantiation.Eager
+);
 
 export { EmptyCellEditorHintContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar.js

@@ -21,7 +21,13 @@ import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 
 let ImplictKernelSelector = class ImplictKernelSelector {
-    constructor(notebook, suggested, notebookKernelService, languageFeaturesService, logService) {
+    constructor(
+        notebook,
+        suggested,
+        notebookKernelService,
+        languageFeaturesService,
+        logService
+    ) {
         const disposables = ( new DisposableStore());
         this.dispose = disposables.dispose.bind(disposables);
         const selectKernel = () => {
@@ -31,32 +37,36 @@ let ImplictKernelSelector = class ImplictKernelSelector {
         disposables.add(notebook.onDidChangeContent(e => {
             for (const event of e.rawEvents) {
                 switch (event.kind) {
-                    case NotebookCellsChangeType.ChangeCellContent:
-                    case NotebookCellsChangeType.ModelChange:
-                    case NotebookCellsChangeType.Move:
-                    case NotebookCellsChangeType.ChangeCellLanguage:
-                        logService.trace('IMPLICIT kernel selection because of change event', event.kind);
-                        selectKernel();
-                        break;
+                case NotebookCellsChangeType.ChangeCellContent:
+                case NotebookCellsChangeType.ModelChange:
+                case NotebookCellsChangeType.Move:
+                case NotebookCellsChangeType.ChangeCellLanguage:
+                    logService.trace("IMPLICIT kernel selection because of change event", event.kind);
+                    selectKernel();
+                    break;
                 }
             }
         }));
-        disposables.add(languageFeaturesService.hoverProvider.register({ scheme: Schemas.vscodeNotebookCell, pattern: notebook.uri.path }, {
+        disposables.add(languageFeaturesService.hoverProvider.register({
+            scheme: Schemas.vscodeNotebookCell,
+            pattern: notebook.uri.path
+        }, {
             provideHover() {
-                logService.trace('IMPLICIT kernel selection because of hover');
+                logService.trace("IMPLICIT kernel selection because of hover");
                 selectKernel();
                 return undefined;
             }
         }));
     }
 };
-ImplictKernelSelector = ( __decorate([
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, ILogService))
-], ImplictKernelSelector));
+ImplictKernelSelector = ( __decorate([( __param(2, INotebookKernelService)), ( __param(3, ILanguageFeaturesService)), ( __param(4, ILogService))], ImplictKernelSelector));
 let KernelStatus = class KernelStatus extends Disposable {
-    constructor(_editorService, _statusbarService, _notebookKernelService, _instantiationService) {
+    constructor(
+        _editorService,
+        _statusbarService,
+        _notebookKernelService,
+        _instantiationService
+    ) {
         super();
         this._editorService = _editorService;
         this._statusbarService = _statusbarService;
@@ -82,8 +92,7 @@ let KernelStatus = class KernelStatus extends Disposable {
             const notebook = activeEditor.textModel;
             if (notebook) {
                 this._showKernelStatus(notebook);
-            }
-            else {
+            } else {
                 this._kernelInfoElement.clear();
             }
         };
@@ -96,47 +105,45 @@ let KernelStatus = class KernelStatus extends Disposable {
     }
     _showKernelStatus(notebook) {
         this._kernelInfoElement.clear();
-        const { selected, suggestions, all } = this._notebookKernelService.getMatchingKernel(notebook);
-        const suggested = (suggestions.length === 1 ? suggestions[0] : undefined)
-            ?? (all.length === 1) ? all[0] : undefined;
+        const {
+            selected,
+            suggestions,
+            all
+        } = this._notebookKernelService.getMatchingKernel(notebook);
+        const suggested = (suggestions.length === 1 ? suggestions[0] : undefined) ?? (all.length === 1) ? all[0] : undefined;
         let isSuggested = false;
         if (all.length === 0) {
             return;
-        }
-        else if (selected || suggested) {
+        } else if (selected || suggested) {
             let kernel = selected;
             if (!kernel) {
                 kernel = suggested;
                 isSuggested = true;
-                this._kernelInfoElement.add(this._instantiationService.createInstance(ImplictKernelSelector, notebook, kernel));
+                this._kernelInfoElement.add(
+                    this._instantiationService.createInstance(ImplictKernelSelector, notebook, kernel)
+                );
             }
             const tooltip = kernel.description ?? kernel.detail ?? kernel.label;
             this._kernelInfoElement.add(this._statusbarService.addEntry({
-                name: ( localize(9260, "Notebook Kernel Info")),
+                name: ( localize(9580, "Notebook Kernel Info")),
                 text: `$(notebook-kernel-select) ${kernel.label}`,
                 ariaLabel: kernel.label,
-                tooltip: isSuggested ? ( localize(9261, "{0} (suggestion)", tooltip)) : tooltip,
-                command: SELECT_KERNEL_ID,
+                tooltip: isSuggested ? ( localize(9581, "{0} (suggestion)", tooltip)) : tooltip,
+                command: SELECT_KERNEL_ID
             }, SELECT_KERNEL_ID, StatusbarAlignment.RIGHT, 10));
             this._kernelInfoElement.add(kernel.onDidChange(() => this._showKernelStatus(notebook)));
-        }
-        else {
+        } else {
             this._kernelInfoElement.add(this._statusbarService.addEntry({
-                name: ( localize(9262, "Notebook Kernel Selection")),
-                text: ( localize(9263, "Select Kernel")),
-                ariaLabel: ( localize(9263, "Select Kernel")),
+                name: ( localize(9582, "Notebook Kernel Selection")),
+                text: ( localize(9583, "Select Kernel")),
+                ariaLabel: ( localize(9583, "Select Kernel")),
                 command: SELECT_KERNEL_ID,
-                kind: 'prominent'
+                kind: "prominent"
             }, SELECT_KERNEL_ID, StatusbarAlignment.RIGHT, 10));
         }
     }
 };
-KernelStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, IInstantiationService))
-], KernelStatus));
+KernelStatus = ( __decorate([( __param(0, IEditorService)), ( __param(1, IStatusbarService)), ( __param(2, INotebookKernelService)), ( __param(3, IInstantiationService))], KernelStatus));
 let ActiveCellStatus = class ActiveCellStatus extends Disposable {
     constructor(_editorService, _statusbarService) {
         super();
@@ -154,8 +161,7 @@ let ActiveCellStatus = class ActiveCellStatus extends Disposable {
             this._itemDisposables.add(activeEditor.onDidChangeSelection(() => this._show(activeEditor)));
             this._itemDisposables.add(activeEditor.onDidChangeActiveCell(() => this._show(activeEditor)));
             this._show(activeEditor);
-        }
-        else {
+        } else {
             this._accessor.clear();
         }
     }
@@ -170,15 +176,14 @@ let ActiveCellStatus = class ActiveCellStatus extends Disposable {
             return;
         }
         const entry = {
-            name: ( localize(9264, "Notebook Editor Selections")),
+            name: ( localize(9584, "Notebook Editor Selections")),
             text: newText,
             ariaLabel: newText,
             command: CENTER_ACTIVE_CELL
         };
         if (!this._accessor.value) {
-            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.activeCellStatus', StatusbarAlignment.RIGHT, 100);
-        }
-        else {
+            this._accessor.value = this._statusbarService.addEntry(entry, "notebook.activeCellStatus", StatusbarAlignment.RIGHT, 100);
+        } else {
             this._accessor.value.update(entry);
         }
     }
@@ -193,17 +198,14 @@ let ActiveCellStatus = class ActiveCellStatus extends Disposable {
         const idxFocused = editor.getCellIndex(activeCell) + 1;
         const numSelected = editor.getSelections().reduce((prev, range) => prev + (range.end - range.start), 0);
         const totalCells = editor.getLength();
-        return numSelected > 1 ?
-            ( localize(9265, "Cell {0} ({1} selected)", idxFocused, numSelected)) :
-            ( localize(9266, "Cell {0} of {1}", idxFocused, totalCells));
+        return numSelected > 1 ? ( localize(9585, "Cell {0} ({1} selected)", idxFocused, numSelected)) : ( localize(9586, "Cell {0} of {1}", idxFocused, totalCells));
     }
 };
-ActiveCellStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService))
-], ActiveCellStatus));
+ActiveCellStatus = ( __decorate([( __param(0, IEditorService)), ( __param(1, IStatusbarService))], ActiveCellStatus));
 let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposable {
-    static { this.ID = 'selectNotebookIndentation'; }
+    static {
+        this.ID = "selectNotebookIndentation";
+    }
     constructor(_editorService, _statusbarService, _configurationService) {
         super();
         this._editorService = _editorService;
@@ -213,7 +215,7 @@ let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposab
         this._accessor = this._register(( new MutableDisposable()));
         this._register(this._editorService.onDidActiveEditorChange(() => this._update()));
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor') || e.affectsConfiguration('notebook')) {
+            if (e.affectsConfiguration("editor") || e.affectsConfiguration("notebook")) {
                 this._update();
             }
         }));
@@ -228,8 +230,7 @@ let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposab
                 this._accessor.clear();
                 this._show(activeEditor);
             }));
-        }
-        else {
+        } else {
             this._accessor.clear();
         }
     }
@@ -244,10 +245,10 @@ let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposab
             return;
         }
         const cellEditorOverridesRaw = editor.notebookOptions.getDisplayOptions().editorOptionsCustomizations;
-        const indentSize = cellEditorOverridesRaw?.['editor.indentSize'] ?? cellOptions?.indentSize;
-        const insertSpaces = cellEditorOverridesRaw?.['editor.insertSpaces'] ?? cellOptions?.insertSpaces;
-        const tabSize = cellEditorOverridesRaw?.['editor.tabSize'] ?? cellOptions?.tabSize;
-        const width = typeof indentSize === 'number' ? indentSize : tabSize;
+        const indentSize = cellEditorOverridesRaw?.["editor.indentSize"] ?? cellOptions?.indentSize;
+        const insertSpaces = cellEditorOverridesRaw?.["editor.insertSpaces"] ?? cellOptions?.insertSpaces;
+        const tabSize = cellEditorOverridesRaw?.["editor.tabSize"] ?? cellOptions?.tabSize;
+        const width = typeof indentSize === "number" ? indentSize : tabSize;
         const message = insertSpaces ? `Spaces: ${width}` : `Tab Size: ${width}`;
         const newText = message;
         if (!newText) {
@@ -255,34 +256,33 @@ let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposab
             return;
         }
         const entry = {
-            name: ( localize(9267, "Notebook Indentation")),
+            name: ( localize(9587, "Notebook Indentation")),
             text: newText,
             ariaLabel: newText,
-            tooltip: ( localize(9268, "Select Indentation")),
+            tooltip: ( localize(9588, "Select Indentation")),
             command: SELECT_NOTEBOOK_INDENTATION_ID
         };
         if (!this._accessor.value) {
-            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.status.indentation', StatusbarAlignment.RIGHT, 100.4);
-        }
-        else {
+            this._accessor.value = this._statusbarService.addEntry(entry, "notebook.status.indentation", StatusbarAlignment.RIGHT, 100.4);
+        } else {
             this._accessor.value.update(entry);
         }
     }
 };
-NotebookIndentationStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, IConfigurationService))
-], NotebookIndentationStatus));
+NotebookIndentationStatus = ( __decorate([( __param(0, IEditorService)), ( __param(1, IStatusbarService)), ( __param(2, IConfigurationService))], NotebookIndentationStatus));
 let NotebookEditorStatusContribution = class NotebookEditorStatusContribution extends Disposable {
-    static { this.ID = 'notebook.contrib.editorStatus'; }
+    static {
+        this.ID = "notebook.contrib.editorStatus";
+    }
     constructor(editorGroupService) {
         super();
         this.editorGroupService = editorGroupService;
         for (const part of editorGroupService.parts) {
             this.createNotebookStatus(part);
         }
-        this._register(editorGroupService.onDidCreateAuxiliaryEditorPart(part => this.createNotebookStatus(part)));
+        this._register(
+            editorGroupService.onDidCreateAuxiliaryEditorPart(part => this.createNotebookStatus(part))
+        );
     }
     createNotebookStatus(part) {
         const disposables = ( new DisposableStore());
@@ -293,7 +293,9 @@ let NotebookEditorStatusContribution = class NotebookEditorStatusContribution ex
         disposables.add(scopedInstantiationService.createInstance(NotebookIndentationStatus));
     }
 };
-NotebookEditorStatusContribution = ( __decorate([
-    ( __param(0, IEditorGroupsService))
-], NotebookEditorStatusContribution));
-registerWorkbenchContribution2(NotebookEditorStatusContribution.ID, NotebookEditorStatusContribution, WorkbenchPhase.AfterRestored);
+NotebookEditorStatusContribution = ( __decorate([( __param(0, IEditorGroupsService))], NotebookEditorStatusContribution));
+registerWorkbenchContribution2(
+    NotebookEditorStatusContribution.ID,
+    NotebookEditorStatusContribution,
+    WorkbenchPhase.AfterRestored
+);

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

@@ -8,7 +8,9 @@ import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vsc
 import { IUserActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userActivity/common/userActivityService.service';
 
 let ExecutionEditorProgressController = class ExecutionEditorProgressController extends Disposable {
-    static { this.id = 'workbench.notebook.executionEditorProgress'; }
+    static {
+        this.id = "workbench.notebook.executionEditorProgress";
+    }
     constructor(_notebookEditor, _notebookExecutionStateService, _userActivity) {
         super();
         this._notebookEditor = _notebookEditor;
@@ -28,10 +30,9 @@ let ExecutionEditorProgressController = class ExecutionEditorProgressController
         if (!this._notebookEditor.hasModel()) {
             return;
         }
-        const cellExecutions = this._notebookExecutionStateService.getCellExecutionsForNotebook(this._notebookEditor.textModel?.uri)
-            .filter(exe => exe.state === NotebookCellExecutionState.Executing);
+        const cellExecutions = this._notebookExecutionStateService.getCellExecutionsForNotebook(this._notebookEditor.textModel?.uri).filter(exe => exe.state === NotebookCellExecutionState.Executing);
         const notebookExecution = this._notebookExecutionStateService.getExecution(this._notebookEditor.textModel?.uri);
-        const executionIsVisible = (exe) => {
+        const executionIsVisible = exe => {
             for (const range of this._notebookEditor.visibleRanges) {
                 for (const cell of this._notebookEditor.getCellsInRange(range)) {
                     if (cell.handle === exe.cellHandle) {
@@ -47,27 +48,25 @@ let ExecutionEditorProgressController = class ExecutionEditorProgressController
         const hasAnyExecution = cellExecutions.length || notebookExecution;
         if (hasAnyExecution && !this._activityMutex.value) {
             this._activityMutex.value = this._userActivity.markActive();
-        }
-        else if (!hasAnyExecution && this._activityMutex.value) {
+        } else if (!hasAnyExecution && this._activityMutex.value) {
             this._activityMutex.clear();
         }
         const shouldShowEditorProgressbarForCellExecutions = cellExecutions.length && !( cellExecutions.some(executionIsVisible)) && !( cellExecutions.some(e => e.isPaused));
         const showEditorProgressBar = !!notebookExecution || shouldShowEditorProgressbarForCellExecutions;
         if (showEditorProgressBar) {
             this._notebookEditor.showProgress();
-        }
-        else {
+        } else {
             this._notebookEditor.hideProgress();
         }
     }
 };
-ExecutionEditorProgressController.__decorator = ( __decorate([
-    throttle(100)
-], ExecutionEditorProgressController.prototype, "_update", null));
-ExecutionEditorProgressController = ( __decorate([
-    ( __param(1, INotebookExecutionStateService)),
-    ( __param(2, IUserActivityService))
-], ExecutionEditorProgressController));
+ExecutionEditorProgressController.__decorator = ( __decorate(
+    [throttle(100)],
+    ExecutionEditorProgressController.prototype,
+    "_update",
+    null
+));
+ExecutionEditorProgressController = ( __decorate([( __param(1, INotebookExecutionStateService)), ( __param(2, IUserActivityService))], ExecutionEditorProgressController));
 registerNotebookContribution(ExecutionEditorProgressController.id, ExecutionEditorProgressController);
 
 export { ExecutionEditorProgressController };