@codingame/monaco-vscode-api 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellProgressBar.js

@@ -32,8 +32,7 @@ let CellProgressBar = class CellProgressBar extends CellContentPart {
                 if (exeState?.state === NotebookCellExecutionState.Executing) {
                     this._updateForExecutionState(element);
                 }
-            }
-            else {
+            } else {
                 this._collapsedProgressBar.hide();
                 if (exeState?.state === NotebookCellExecutionState.Executing) {
                     this._updateForExecutionState(element);
@@ -46,15 +45,12 @@ let CellProgressBar = class CellProgressBar extends CellContentPart {
         const progressBar = element.isInputCollapsed ? this._collapsedProgressBar : this._progressBar;
         if (exeState?.state === NotebookCellExecutionState.Executing && (!exeState.didPause || element.isInputCollapsed)) {
             showProgressBar(progressBar);
-        }
-        else {
+        } else {
             progressBar.hide();
         }
     }
 };
-CellProgressBar = ( __decorate([
-    ( __param(2, INotebookExecutionStateService))
-], CellProgressBar));
+CellProgressBar = ( __decorate([( __param(2, INotebookExecutionStateService))], CellProgressBar));
 function showProgressBar(progressBar) {
     progressBar.infinite().show(500);
 }

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellStatusPart.js

@@ -26,7 +26,16 @@ import { HoverPosition } from '../../../../../../base/browser/ui/hover/hoverWidg
 
 const $ = $$1;
 let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
-    constructor(_notebookEditor, _cellContainer, editorPart, _editor, _instantiationService, hoverService, configurationService, _themeService) {
+    constructor(
+        _notebookEditor,
+        _cellContainer,
+        editorPart,
+        _editor,
+        _instantiationService,
+        hoverService,
+        configurationService,
+        _themeService
+    ) {
         super();
         this._notebookEditor = _notebookEditor;
         this._cellContainer = _cellContainer;
@@ -38,66 +47,72 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
         this.width = 0;
         this._onDidClick = this._register(( new Emitter()));
         this.onDidClick = this._onDidClick.event;
-        this.statusBarContainer = append(editorPart, $('.cell-statusbar-container'));
+        this.statusBarContainer = append(editorPart, $(".cell-statusbar-container"));
         this.statusBarContainer.tabIndex = -1;
-        const leftItemsContainer = append(this.statusBarContainer, $('.cell-status-left'));
-        const rightItemsContainer = append(this.statusBarContainer, $('.cell-status-right'));
-        this.leftItemsContainer = append(leftItemsContainer, $('.cell-contributed-items.cell-contributed-items-left'));
-        this.rightItemsContainer = append(rightItemsContainer, $('.cell-contributed-items.cell-contributed-items-right'));
+        const leftItemsContainer = append(this.statusBarContainer, $(".cell-status-left"));
+        const rightItemsContainer = append(this.statusBarContainer, $(".cell-status-right"));
+        this.leftItemsContainer = append(
+            leftItemsContainer,
+            $(".cell-contributed-items.cell-contributed-items-left")
+        );
+        this.rightItemsContainer = append(
+            rightItemsContainer,
+            $(".cell-contributed-items.cell-contributed-items-right")
+        );
         this.itemsDisposable = this._register(( new DisposableStore()));
         this.hoverDelegate = new (class {
             constructor() {
                 this._lastHoverHideTime = 0;
-                this.showHover = (options) => {
+                this.showHover = options => {
                     options.position = options.position ?? {};
                     options.position.hoverPosition = HoverPosition.ABOVE;
                     return hoverService.showInstantHover(options);
                 };
-                this.placement = 'element';
+                this.placement = "element";
             }
             get delay() {
-                return Date.now() - this._lastHoverHideTime < 200
-                    ? 0
-                    : configurationService.getValue('workbench.hover.delay');
+                return Date.now() - this._lastHoverHideTime < 200 ?
+                0 : configurationService.getValue("workbench.hover.delay");
             }
             onDidHideHover() {
                 this._lastHoverHideTime = Date.now();
             }
-        });
-        this._register(this._themeService.onDidColorThemeChange(() => this.currentContext && this.updateContext(this.currentContext)));
-        this._register(addDisposableListener(this.statusBarContainer, EventType.CLICK, e => {
-            if (e.target === leftItemsContainer || e.target === rightItemsContainer || e.target === this.statusBarContainer) {
-                this._onDidClick.fire({
-                    type: ClickTargetType.Container,
-                    event: e
-                });
-            }
-            else {
-                const target = e.target;
-                let itemHasCommand = false;
-                if (target && isHTMLElement(target)) {
-                    const targetElement = target;
-                    if (targetElement.classList.contains('cell-status-item-has-command')) {
-                        itemHasCommand = true;
-                    }
-                    else if (targetElement.parentElement && targetElement.parentElement.classList.contains('cell-status-item-has-command')) {
-                        itemHasCommand = true;
-                    }
-                }
-                if (itemHasCommand) {
+        })();
+        this._register(
+            this._themeService.onDidColorThemeChange(() => this.currentContext && this.updateContext(this.currentContext))
+        );
+        this._register(
+            addDisposableListener(this.statusBarContainer, EventType.CLICK, e => {
+                if (e.target === leftItemsContainer || e.target === rightItemsContainer || e.target === this.statusBarContainer) {
                     this._onDidClick.fire({
-                        type: ClickTargetType.ContributedCommandItem,
-                        event: e
-                    });
-                }
-                else {
-                    this._onDidClick.fire({
-                        type: ClickTargetType.ContributedTextItem,
+                        type: ClickTargetType.Container,
                         event: e
                     });
+                } else {
+                    const target = e.target;
+                    let itemHasCommand = false;
+                    if (target && isHTMLElement(target)) {
+                        const targetElement = target;
+                        if (targetElement.classList.contains("cell-status-item-has-command")) {
+                            itemHasCommand = true;
+                        } else if (targetElement.parentElement && targetElement.parentElement.classList.contains("cell-status-item-has-command")) {
+                            itemHasCommand = true;
+                        }
+                    }
+                    if (itemHasCommand) {
+                        this._onDidClick.fire({
+                            type: ClickTargetType.ContributedCommandItem,
+                            event: e
+                        });
+                    } else {
+                        this._onDidClick.fire({
+                            type: ClickTargetType.ContributedTextItem,
+                            event: e
+                        });
+                    }
                 }
-            }
-        }));
+            })
+        );
     }
     didRenderCell(element) {
         if (this._notebookEditor.hasModel()) {
@@ -113,16 +128,13 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
             const updateFocusModeForEditorEvent = () => {
                 if (this._editor && (this._editor.hasWidgetFocus() || (getActiveElement(this.statusBarContainer.ownerDocument) && this.statusBarContainer.contains(getActiveElement(this.statusBarContainer.ownerDocument))))) {
                     element.focusMode = CellFocusMode.Editor;
-                }
-                else {
+                } else {
                     const currentMode = element.focusMode;
                     if (currentMode === CellFocusMode.ChatInput) {
                         element.focusMode = CellFocusMode.ChatInput;
-                    }
-                    else if (currentMode === CellFocusMode.Output && this._notebookEditor.hasWebviewFocus()) {
+                    } else if (currentMode === CellFocusMode.Output && this._notebookEditor.hasWebviewFocus()) {
                         element.focusMode = CellFocusMode.Output;
-                    }
-                    else {
+                    } else {
                         element.focusMode = CellFocusMode.Container;
                     }
                 }
@@ -132,14 +144,16 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
             }));
             this.cellDisposables.add(this._editor.onDidBlurEditorWidget(() => {
                 const activeElement = getActiveElement(this.statusBarContainer.ownerDocument);
-                if (this._notebookEditor.hasEditorFocus() &&
-                    !(activeElement && this.statusBarContainer.contains(activeElement))) {
+                if (this._notebookEditor.hasEditorFocus() && !(activeElement && this.statusBarContainer.contains(activeElement))) {
                     updateFocusModeForEditorEvent();
                 }
             }));
             this.cellDisposables.add(this.onDidClick(e => {
                 if (this.currentCell instanceof CodeCellViewModel && e.type !== ClickTargetType.ContributedCommandItem && this._editor) {
-                    const target = this._editor.getTargetAtClientPoint(e.event.clientX, e.event.clientY - this._notebookEditor.notebookOptions.computeEditorStatusbarHeight(this.currentCell.internalMetadata, this.currentCell.uri));
+                    const target = this._editor.getTargetAtClientPoint(
+                        e.event.clientX,
+                        e.event.clientY - this._notebookEditor.notebookOptions.computeEditorStatusbarHeight(this.currentCell.internalMetadata, this.currentCell.uri)
+                    );
                     if (target?.position) {
                         this._editor.setPosition(target.position);
                         this._editor.focus();
@@ -149,7 +163,10 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
         }
     }
     updateInternalLayoutNow(element) {
-        this._cellContainer.classList.toggle('cell-statusbar-hidden', this._notebookEditor.notebookOptions.computeEditorStatusbarHeight(element.internalMetadata, element.uri) === 0);
+        this._cellContainer.classList.toggle(
+            "cell-statusbar-hidden",
+            this._notebookEditor.notebookOptions.computeEditorStatusbarHeight(element.internalMetadata, element.uri) === 0
+        );
         const layoutInfo = element.layoutInfo;
         const width = layoutInfo.editorWidth;
         if (!width) {
@@ -175,15 +192,19 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
                 this.updateInternalLayoutNow(this.currentContext.cell);
             }
         }));
-        this.itemsDisposable.add(this.currentContext.cell.onDidChangeCellStatusBarItems(() => this.updateRenderedItems()));
-        this.itemsDisposable.add(this.currentContext.notebookEditor.onDidChangeActiveCell(() => this.updateActiveCell()));
+        this.itemsDisposable.add(
+            this.currentContext.cell.onDidChangeCellStatusBarItems(() => this.updateRenderedItems())
+        );
+        this.itemsDisposable.add(
+            this.currentContext.notebookEditor.onDidChangeActiveCell(() => this.updateActiveCell())
+        );
         this.updateInternalLayoutNow(this.currentContext.cell);
         this.updateActiveCell();
         this.updateRenderedItems();
     }
     updateActiveCell() {
         const isActiveCell = this.currentContext.notebookEditor.getActiveCell() === this.currentContext?.cell;
-        this.statusBarContainer.classList.toggle('is-active-cell', isActiveCell);
+        this.statusBarContainer.classList.toggle("is-active-cell", isActiveCell);
     }
     updateRenderedItems() {
         const items = this.currentContext.cell.getCellStatusBarItems();
@@ -205,9 +226,15 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
                 const existingItem = renderedItems[i];
                 if (existingItem) {
                     existingItem.updateItem(newLeftItem, maxItemWidth);
-                }
-                else {
-                    const item = this._instantiationService.createInstance(CellStatusBarItem, this.currentContext, this.hoverDelegate, this._editor, newLeftItem, maxItemWidth);
+                } else {
+                    const item = this._instantiationService.createInstance(
+                        CellStatusBarItem,
+                        this.currentContext,
+                        this.hoverDelegate,
+                        this._editor,
+                        newLeftItem,
+                        maxItemWidth
+                    );
                     renderedItems.push(item);
                     container.appendChild(item.container);
                 }
@@ -222,17 +249,23 @@ let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
         dispose(this.rightItems);
     }
 };
-CellEditorStatusBar = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IHoverService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IThemeService))
-], CellEditorStatusBar));
+CellEditorStatusBar = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IHoverService)), ( __param(6, IConfigurationService)), ( __param(7, IThemeService))], CellEditorStatusBar));
 let CellStatusBarItem = class CellStatusBarItem extends Disposable {
     set maxWidth(v) {
-        this.container.style.maxWidth = v + 'px';
+        this.container.style.maxWidth = v + "px";
     }
-    constructor(_context, _hoverDelegate, _editor, itemModel, maxWidth, _telemetryService, _commandService, _notificationService, _themeService, _hoverService) {
+    constructor(
+        _context,
+        _hoverDelegate,
+        _editor,
+        itemModel,
+        maxWidth,
+        _telemetryService,
+        _commandService,
+        _notificationService,
+        _themeService,
+        _hoverService
+    ) {
         super();
         this._context = _context;
         this._hoverDelegate = _hoverDelegate;
@@ -242,25 +275,23 @@ let CellStatusBarItem = class CellStatusBarItem extends Disposable {
         this._notificationService = _notificationService;
         this._themeService = _themeService;
         this._hoverService = _hoverService;
-        this.container = $('.cell-status-item');
+        this.container = $(".cell-status-item");
         this._itemDisposables = this._register(( new DisposableStore()));
         this.updateItem(itemModel, maxWidth);
     }
     updateItem(item, maxWidth) {
         this._itemDisposables.clear();
         if (!this._currentItem || this._currentItem.text !== item.text) {
-            this._itemDisposables.add(( new SimpleIconLabel(this.container))).text = item.text.replace(/\n/g, ' ');
+            this._itemDisposables.add(( new SimpleIconLabel(this.container))).text = item.text.replace(/\n/g, " ");
         }
-        const resolveColor = (color) => {
-            return isThemeColor(color) ?
-                (this._themeService.getColorTheme().getColor(color.id)?.toString() || '') :
-                color;
+        const resolveColor = color => {
+            return isThemeColor(color) ? (this._themeService.getColorTheme().getColor(color.id)?.toString() || "") : color;
         };
-        this.container.style.color = item.color ? resolveColor(item.color) : '';
-        this.container.style.backgroundColor = item.backgroundColor ? resolveColor(item.backgroundColor) : '';
-        this.container.style.opacity = item.opacity ? item.opacity : '';
-        this.container.classList.toggle('cell-status-item-show-when-active', !!item.onlyShowWhenActive);
-        if (typeof maxWidth === 'number') {
+        this.container.style.color = item.color ? resolveColor(item.color) : "";
+        this.container.style.backgroundColor = item.backgroundColor ? resolveColor(item.backgroundColor) : "";
+        this.container.style.opacity = item.opacity ? item.opacity : "";
+        this.container.classList.toggle("cell-status-item-show-when-active", !!item.onlyShowWhenActive);
+        if (typeof maxWidth === "number") {
             this.maxWidth = maxWidth;
         }
         let ariaLabel;
@@ -268,17 +299,21 @@ let CellStatusBarItem = class CellStatusBarItem extends Disposable {
         if (item.accessibilityInformation) {
             ariaLabel = item.accessibilityInformation.label;
             role = item.accessibilityInformation.role;
+        } else {
+            ariaLabel = item.text ? stripIcons(item.text).trim() : "";
         }
-        else {
-            ariaLabel = item.text ? stripIcons(item.text).trim() : '';
-        }
-        this.container.setAttribute('aria-label', ariaLabel);
-        this.container.setAttribute('role', role || '');
+        this.container.setAttribute("aria-label", ariaLabel);
+        this.container.setAttribute("role", role || "");
         if (item.tooltip) {
-            const hoverContent = typeof item.tooltip === 'string' ? item.tooltip : { markdown: item.tooltip, markdownNotSupportedFallback: undefined };
-            this._itemDisposables.add(this._hoverService.setupManagedHover(this._hoverDelegate, this.container, hoverContent));
+            const hoverContent = typeof item.tooltip === "string" ? item.tooltip : {
+                markdown: item.tooltip,
+                markdownNotSupportedFallback: undefined
+            };
+            this._itemDisposables.add(
+                this._hoverService.setupManagedHover(this._hoverDelegate, this.container, hoverContent)
+            );
         }
-        this.container.classList.toggle('cell-status-item-has-command', !!item.command);
+        this.container.classList.toggle("cell-status-item-has-command", !!item.command);
         if (item.command) {
             this.container.tabIndex = 0;
             this._itemDisposables.add(addDisposableListener(this.container, EventType.CLICK, _e => {
@@ -290,9 +325,8 @@ let CellStatusBarItem = class CellStatusBarItem extends Disposable {
                     this.executeCommand();
                 }
             }));
-        }
-        else {
-            this.container.removeAttribute('tabIndex');
+        } else {
+            this.container.removeAttribute("tabIndex");
         }
         this._currentItem = item;
     }
@@ -301,27 +335,23 @@ let CellStatusBarItem = class CellStatusBarItem extends Disposable {
         if (!command) {
             return;
         }
-        const id = typeof command === 'string' ? command : command.id;
-        const args = typeof command === 'string' ? [] : command.arguments ?? [];
-        if (typeof command === 'string' || !command.arguments || !Array.isArray(command.arguments) || command.arguments.length === 0) {
+        const id = typeof command === "string" ? command : command.id;
+        const args = typeof command === "string" ? [] : command.arguments ?? [];
+        if (typeof command === "string" || !command.arguments || !Array.isArray(command.arguments) || command.arguments.length === 0) {
             args.unshift(this._context);
         }
-        this._telemetryService.publicLog2('workbenchActionExecuted', { id, from: 'cell status bar' });
+        this._telemetryService.publicLog2("workbenchActionExecuted", {
+            id,
+            from: "cell status bar"
+        });
         try {
             this._editor?.focus();
             await this._commandService.executeCommand(id, ...args);
-        }
-        catch (error) {
+        } catch (error) {
             this._notificationService.error(toErrorMessage(error));
         }
     }
 };
-CellStatusBarItem = ( __decorate([
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ICommandService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IThemeService)),
-    ( __param(9, IHoverService))
-], CellStatusBarItem));
+CellStatusBarItem = ( __decorate([( __param(5, ITelemetryService)), ( __param(6, ICommandService)), ( __param(7, INotificationService)), ( __param(8, IThemeService)), ( __param(9, IHoverService))], CellStatusBarItem));
 
 export { CellEditorStatusBar };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellToolbars.js

@@ -19,7 +19,15 @@ import { WorkbenchToolBar } from '../../../../../../platform/actions/browser/too
 import { createInstantHoverDelegate } from '../../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 
 let BetweenCellToolbar = class BetweenCellToolbar extends CellOverlayPart {
-    constructor(_notebookEditor, _titleToolbarContainer, _bottomCellToolbarContainer, instantiationService, contextMenuService, contextKeyService, menuService) {
+    constructor(
+        _notebookEditor,
+        _titleToolbarContainer,
+        _bottomCellToolbarContainer,
+        instantiationService,
+        contextMenuService,
+        contextKeyService,
+        menuService
+    ) {
         super();
         this._notebookEditor = _notebookEditor;
         this._bottomCellToolbarContainer = _bottomCellToolbarContainer;
@@ -35,24 +43,30 @@ let BetweenCellToolbar = class BetweenCellToolbar extends CellOverlayPart {
         const betweenCellToolbar = this._register(( new ToolBar(this._bottomCellToolbarContainer, this.contextMenuService, {
             actionViewItemProvider: (action, options) => {
                 if (action instanceof MenuItemAction) {
-                    if (this._notebookEditor.notebookOptions.getDisplayOptions().insertToolbarAlignment === 'center') {
-                        return this.instantiationService.createInstance(CodiconActionViewItem, action, { hoverDelegate: options.hoverDelegate });
-                    }
-                    else {
-                        return this.instantiationService.createInstance(MenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate });
+                    if (this._notebookEditor.notebookOptions.getDisplayOptions().insertToolbarAlignment === "center") {
+                        return this.instantiationService.createInstance(CodiconActionViewItem, action, {
+                            hoverDelegate: options.hoverDelegate
+                        });
+                    } else {
+                        return this.instantiationService.createInstance(MenuEntryActionViewItem, action, {
+                            hoverDelegate: options.hoverDelegate
+                        });
                     }
                 }
                 return undefined;
             }
         })));
         this._betweenCellToolbar = betweenCellToolbar;
-        const menu = this._register(this.menuService.createMenu(this._notebookEditor.creationOptions.menuIds.cellInsertToolbar, this.contextKeyService));
+        const menu = this._register(this.menuService.createMenu(
+            this._notebookEditor.creationOptions.menuIds.cellInsertToolbar,
+            this.contextKeyService
+        ));
         const updateActions = () => {
             const actions = getCellToolbarActions(menu);
             betweenCellToolbar.setActions(actions.primary, actions.secondary);
         };
         this._register(menu.onDidChange(() => updateActions()));
-        this._register(this._notebookEditor.notebookOptions.onDidChangeOptions((e) => {
+        this._register(this._notebookEditor.notebookOptions.onDidChangeOptions(e => {
             if (e.insertToolbarAlignment) {
                 updateActions();
             }
@@ -67,7 +81,7 @@ let BetweenCellToolbar = class BetweenCellToolbar extends CellOverlayPart {
                 ui: true,
                 cell: element,
                 notebookEditor: this._notebookEditor,
-                source: 'insertToolbar',
+                source: "insertToolbar",
                 $mid: MarshalledId.NotebookCellActionContext
             };
         }
@@ -78,24 +92,24 @@ let BetweenCellToolbar = class BetweenCellToolbar extends CellOverlayPart {
         this._bottomCellToolbarContainer.style.transform = `translateY(${bottomToolbarOffset}px)`;
     }
 };
-BetweenCellToolbar = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IMenuService))
-], BetweenCellToolbar));
+BetweenCellToolbar = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IContextMenuService)), ( __param(5, IContextKeyService)), ( __param(6, IMenuService))], BetweenCellToolbar));
 let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
     get hasActions() {
         if (!this._model) {
             return false;
         }
-        return this._model.actions.primary.length
-            + this._model.actions.secondary.length
-            + this._model.deleteActions.primary.length
-            + this._model.deleteActions.secondary.length
-            > 0;
+        return this._model.actions.primary.length + this._model.actions.secondary.length + this._model.deleteActions.primary.length + this._model.deleteActions.secondary.length > 0;
     }
-    constructor(toolbarContainer, _rootClassDelegate, toolbarId, deleteToolbarId, _notebookEditor, contextKeyService, menuService, instantiationService) {
+    constructor(
+        toolbarContainer,
+        _rootClassDelegate,
+        toolbarId,
+        deleteToolbarId,
+        _notebookEditor,
+        contextKeyService,
+        menuService,
+        instantiationService
+    ) {
         super();
         this.toolbarContainer = toolbarContainer;
         this._rootClassDelegate = _rootClassDelegate;
@@ -129,14 +143,18 @@ let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
             return this._view;
         }
         const hoverDelegate = this._register(createInstantHoverDelegate());
-        const toolbar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, {
-            actionViewItemProvider: (action, options) => {
-                return createActionViewItem(this.instantiationService, action, options);
-            },
-            renderDropdownAsChildElement: true,
-            hoverDelegate
-        }));
-        const deleteToolbar = this._register(this.instantiationService.invokeFunction(accessor => createDeleteToolbar(accessor, this.toolbarContainer, hoverDelegate, 'cell-delete-toolbar')));
+        const toolbar = this._register(
+            this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, {
+                actionViewItemProvider: (action, options) => {
+                    return createActionViewItem(this.instantiationService, action, options);
+                },
+                renderDropdownAsChildElement: true,
+                hoverDelegate
+            })
+        );
+        const deleteToolbar = this._register(this.instantiationService.invokeFunction(
+            accessor => createDeleteToolbar(accessor, this.toolbarContainer, hoverDelegate, "cell-delete-toolbar")
+        ));
         if (model.deleteActions.primary.length !== 0 || model.deleteActions.secondary.length !== 0) {
             deleteToolbar.setActions(model.deleteActions.primary, model.deleteActions.secondary);
         }
@@ -154,13 +172,18 @@ let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
     didRenderCell(element) {
         const model = this._initializeModel();
         const view = this._initialize(model, element);
-        this.cellDisposables.add(registerCellToolbarStickyScroll(this._notebookEditor, element, this.toolbarContainer, { extraOffset: 4, min: -14 }));
+        this.cellDisposables.add(
+            registerCellToolbarStickyScroll(this._notebookEditor, element, this.toolbarContainer, {
+                extraOffset: 4,
+                min: -14
+            })
+        );
         if (this._notebookEditor.hasModel()) {
             const toolbarContext = {
                 ui: true,
                 cell: element,
                 notebookEditor: this._notebookEditor,
-                source: 'cellToolbar',
+                source: "cellToolbar",
                 $mid: MarshalledId.NotebookCellActionContext
             };
             this.updateContext(view, toolbarContext);
@@ -183,10 +206,10 @@ let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
             const actions = getCellToolbarActions(menu);
             this.updateActions(toolbar, actions);
         }));
-        this._rootClassDelegate.toggle('cell-toolbar-dropdown-active', false);
+        this._rootClassDelegate.toggle("cell-toolbar-dropdown-active", false);
         this._register(toolbar.onDidChangeDropdownVisibility(visible => {
             dropdownIsVisible = visible;
-            this._rootClassDelegate.toggle('cell-toolbar-dropdown-active', visible);
+            this._rootClassDelegate.toggle("cell-toolbar-dropdown-active", visible);
             if (deferredUpdate && !visible) {
                 disposableTimeout(() => {
                     deferredUpdate?.();
@@ -202,22 +225,19 @@ let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
             this._notebookEditor.focus();
         }
         if (actions.primary.length || actions.secondary.length) {
-            this._rootClassDelegate.toggle('cell-has-toolbar-actions', true);
+            this._rootClassDelegate.toggle("cell-has-toolbar-actions", true);
             this._onDidUpdateActions.fire();
-        }
-        else {
-            this._rootClassDelegate.toggle('cell-has-toolbar-actions', false);
+        } else {
+            this._rootClassDelegate.toggle("cell-has-toolbar-actions", false);
             this._onDidUpdateActions.fire();
         }
     }
 };
-CellTitleToolbarPart = ( __decorate([
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IInstantiationService))
-], CellTitleToolbarPart));
+CellTitleToolbarPart = ( __decorate([( __param(5, IContextKeyService)), ( __param(6, IMenuService)), ( __param(7, IInstantiationService))], CellTitleToolbarPart));
 function getCellToolbarActions(menu) {
-    return getActionBarActions(menu.getActions({ shouldForwardArgs: true }), g => /^inline/.test(g));
+    return getActionBarActions(menu.getActions({
+        shouldForwardArgs: true
+    }), g => /^inline/.test(g));
 }
 function createDeleteToolbar(accessor, container, hoverDelegate, elementClass) {
     const contextMenuService = accessor.get(IContextMenuService);