@codingame/monaco-vscode-api 1.85.0 → 1.85.1

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

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { defaultProgressBarStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { CellContentPart } from '../cellPart.js';
+import { NotebookCellExecutionState } from '../../../common/notebookCommon.js';
+import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+let CellProgressBar = class CellProgressBar extends CellContentPart {
+    constructor(editorContainer, collapsedInputContainer, _notebookExecutionStateService) {
+        super();
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._progressBar = this._register(( new ProgressBar(editorContainer, defaultProgressBarStyles)));
+        this._progressBar.hide();
+        this._collapsedProgressBar = this._register(( new ProgressBar(collapsedInputContainer, defaultProgressBarStyles)));
+        this._collapsedProgressBar.hide();
+    }
+    didRenderCell(element) {
+        this._updateForExecutionState(element);
+    }
+    updateForExecutionState(element, e) {
+        this._updateForExecutionState(element, e);
+    }
+    updateState(element, e) {
+        if (e.metadataChanged || e.internalMetadataChanged) {
+            this._updateForExecutionState(element);
+        }
+        if (e.inputCollapsedChanged) {
+            const exeState = this._notebookExecutionStateService.getCellExecution(element.uri);
+            if (element.isInputCollapsed) {
+                this._progressBar.hide();
+                if (exeState?.state === NotebookCellExecutionState.Executing) {
+                    this._updateForExecutionState(element);
+                }
+            }
+            else {
+                this._collapsedProgressBar.hide();
+                if (exeState?.state === NotebookCellExecutionState.Executing) {
+                    this._updateForExecutionState(element);
+                }
+            }
+        }
+    }
+    _updateForExecutionState(element, e) {
+        const exeState = e?.changed ?? this._notebookExecutionStateService.getCellExecution(element.uri);
+        const progressBar = element.isInputCollapsed ? this._collapsedProgressBar : this._progressBar;
+        if (exeState?.state === NotebookCellExecutionState.Executing && (!exeState.didPause || element.isInputCollapsed)) {
+            showProgressBar(progressBar);
+        }
+        else {
+            progressBar.hide();
+        }
+    }
+};
+CellProgressBar = ( __decorate([
+    ( __param(2, INotebookExecutionStateService))
+], CellProgressBar));
+function showProgressBar(progressBar) {
+    progressBar.infinite().show(500);
+}
+export { CellProgressBar };

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

@@ -0,0 +1,303 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { SimpleIconLabel } from '../../../../../../base/browser/ui/iconLabel/simpleIconLabel.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { DisposableStore, dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isThemeColor } from 'monaco-editor/esm/vs/editor/common/editorCommon.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { CellFocusMode } from '../../notebookBrowser.js';
+import { CellContentPart } from '../cellPart.js';
+import { CodeCellViewModel } from '../../viewModel/codeCellViewModel.js';
+import { setupCustomHover } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabelHover.js';
+import { IHoverService } from '../../../../../services/hover/browser/hover.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+const $ = dom.$;
+let CellEditorStatusBar = class CellEditorStatusBar extends CellContentPart {
+    constructor(_notebookEditor, _cellContainer, editorPart, _editor, _instantiationService, hoverService, configurationService, _themeService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._cellContainer = _cellContainer;
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._themeService = _themeService;
+        this.leftItems = [];
+        this.rightItems = [];
+        this.width = 0;
+        this._onDidClick = this._register(( new Emitter()));
+        this.onDidClick = this._onDidClick.event;
+        this.statusBarContainer = dom.append(editorPart, $('.cell-statusbar-container'));
+        this.statusBarContainer.tabIndex = -1;
+        const leftItemsContainer = dom.append(this.statusBarContainer, $('.cell-status-left'));
+        const rightItemsContainer = dom.append(this.statusBarContainer, $('.cell-status-right'));
+        this.leftItemsContainer = dom.append(leftItemsContainer, $('.cell-contributed-items.cell-contributed-items-left'));
+        this.rightItemsContainer = dom.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) => {
+                    options.position = options.position ?? {};
+                    options.position.hoverPosition = 3 ;
+                    return hoverService.showHover(options);
+                };
+                this.placement = 'element';
+            }
+            get 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(dom.addDisposableListener(this.statusBarContainer, dom.EventType.CLICK, e => {
+            if (e.target === leftItemsContainer || e.target === rightItemsContainer || e.target === this.statusBarContainer) {
+                this._onDidClick.fire({
+                    type: 0 ,
+                    event: e
+                });
+            }
+            else {
+                if (e.target.classList.contains('cell-status-item-has-command')) {
+                    this._onDidClick.fire({
+                        type: 2 ,
+                        event: e
+                    });
+                }
+                else {
+                    this._onDidClick.fire({
+                        type: 1 ,
+                        event: e
+                    });
+                }
+            }
+        }));
+    }
+    didRenderCell(element) {
+        this.updateContext({
+            ui: true,
+            cell: element,
+            notebookEditor: this._notebookEditor,
+            $mid: 13
+        });
+        if (this._editor) {
+            const updateFocusModeForEditorEvent = () => {
+                if (this._editor && (this._editor.hasWidgetFocus() || (this.statusBarContainer.ownerDocument.activeElement && this.statusBarContainer.contains(this.statusBarContainer.ownerDocument.activeElement)))) {
+                    element.focusMode = CellFocusMode.Editor;
+                }
+                else {
+                    const currentMode = element.focusMode;
+                    if (currentMode === CellFocusMode.ChatInput) {
+                        element.focusMode = CellFocusMode.ChatInput;
+                    }
+                    else if (currentMode === CellFocusMode.Output && this._notebookEditor.hasWebviewFocus()) {
+                        element.focusMode = CellFocusMode.Output;
+                    }
+                    else {
+                        element.focusMode = CellFocusMode.Container;
+                    }
+                }
+            };
+            this.cellDisposables.add(this._editor.onDidFocusEditorWidget(() => {
+                updateFocusModeForEditorEvent();
+            }));
+            this.cellDisposables.add(this._editor.onDidBlurEditorWidget(() => {
+                if (this._notebookEditor.hasEditorFocus() &&
+                    !(this.statusBarContainer.ownerDocument.activeElement && this.statusBarContainer.contains(this.statusBarContainer.ownerDocument.activeElement))) {
+                    updateFocusModeForEditorEvent();
+                }
+            }));
+            this.cellDisposables.add(this.onDidClick(e => {
+                if (this.currentCell instanceof CodeCellViewModel && e.type !== 2  && this._editor) {
+                    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();
+                    }
+                }
+            }));
+        }
+    }
+    updateInternalLayoutNow(element) {
+        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) {
+            return;
+        }
+        this.width = width;
+        this.statusBarContainer.style.width = `${width}px`;
+        const maxItemWidth = this.getMaxItemWidth();
+        this.leftItems.forEach(item => item.maxWidth = maxItemWidth);
+        this.rightItems.forEach(item => item.maxWidth = maxItemWidth);
+    }
+    getMaxItemWidth() {
+        return this.width / 2;
+    }
+    updateContext(context) {
+        this.currentContext = context;
+        this.itemsDisposable.clear();
+        if (!this.currentContext) {
+            return;
+        }
+        this.itemsDisposable.add(this.currentContext.cell.onDidChangeLayout(() => {
+            if (this.currentContext) {
+                this.updateInternalLayoutNow(this.currentContext.cell);
+            }
+        }));
+        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);
+    }
+    updateRenderedItems() {
+        const items = this.currentContext.cell.getCellStatusBarItems();
+        items.sort((itemA, itemB) => {
+            return (itemB.priority ?? 0) - (itemA.priority ?? 0);
+        });
+        const maxItemWidth = this.getMaxItemWidth();
+        const newLeftItems = items.filter(item => item.alignment === 1 );
+        const newRightItems = items.filter(item => item.alignment === 2 ).reverse();
+        const updateItems = (renderedItems, newItems, container) => {
+            if (renderedItems.length > newItems.length) {
+                const deleted = renderedItems.splice(newItems.length, renderedItems.length - newItems.length);
+                for (const deletedItem of deleted) {
+                    container.removeChild(deletedItem.container);
+                    deletedItem.dispose();
+                }
+            }
+            newItems.forEach((newLeftItem, i) => {
+                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);
+                    renderedItems.push(item);
+                    container.appendChild(item.container);
+                }
+            });
+        };
+        updateItems(this.leftItems, newLeftItems, this.leftItemsContainer);
+        updateItems(this.rightItems, newRightItems, this.rightItemsContainer);
+    }
+    dispose() {
+        super.dispose();
+        dispose(this.leftItems);
+        dispose(this.rightItems);
+    }
+};
+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';
+    }
+    constructor(_context, _hoverDelegate, _editor, itemModel, maxWidth, _telemetryService, _commandService, _notificationService, _themeService) {
+        super();
+        this._context = _context;
+        this._hoverDelegate = _hoverDelegate;
+        this._editor = _editor;
+        this._telemetryService = _telemetryService;
+        this._commandService = _commandService;
+        this._notificationService = _notificationService;
+        this._themeService = _themeService;
+        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) {
+            ( new SimpleIconLabel(this.container)).text = item.text.replace(/\n/g, ' ');
+        }
+        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.maxWidth = maxWidth;
+        }
+        let ariaLabel;
+        let role;
+        if (item.accessibilityInformation) {
+            ariaLabel = item.accessibilityInformation.label;
+            role = item.accessibilityInformation.role;
+        }
+        else {
+            ariaLabel = item.text ? stripIcons(item.text).trim() : '';
+        }
+        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 };
+            this._itemDisposables.add(setupCustomHover(this._hoverDelegate, this.container, hoverContent));
+        }
+        this.container.classList.toggle('cell-status-item-has-command', !!item.command);
+        if (item.command) {
+            this.container.tabIndex = 0;
+            this._itemDisposables.add(dom.addDisposableListener(this.container, dom.EventType.CLICK, _e => {
+                this.executeCommand();
+            }));
+            this._itemDisposables.add(dom.addDisposableListener(this.container, dom.EventType.KEY_DOWN, e => {
+                const event = ( new StandardKeyboardEvent(e));
+                if (event.equals(10 ) || event.equals(3 )) {
+                    this.executeCommand();
+                }
+            }));
+        }
+        else {
+            this.container.removeAttribute('tabIndex');
+        }
+        this._currentItem = item;
+    }
+    async executeCommand() {
+        const command = this._currentItem.command;
+        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) {
+            args.unshift(this._context);
+        }
+        this._telemetryService.publicLog2('workbenchActionExecuted', { id, from: 'cell status bar' });
+        try {
+            this._editor?.focus();
+            await this._commandService.executeCommand(id, ...args);
+        }
+        catch (error) {
+            this._notificationService.error(toErrorMessage(error));
+        }
+    }
+};
+CellStatusBarItem = ( __decorate([
+    ( __param(5, ITelemetryService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IThemeService))
+], CellStatusBarItem));
+export { CellEditorStatusBar };

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

@@ -0,0 +1,24 @@
+import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
+function registerCellToolbarStickyScroll(notebookEditor, cell, element, opts) {
+    const extraOffset = opts?.extraOffset ?? 0;
+    const min = opts?.min ?? 0;
+    const updateForScroll = () => {
+        if (cell.isInputCollapsed) {
+            element.style.top = '';
+        }
+        else {
+            const stickyHeight = notebookEditor.getLayoutInfo().stickyHeight;
+            const scrollTop = notebookEditor.scrollTop;
+            const elementTop = notebookEditor.getAbsoluteTopOfElement(cell);
+            const diff = scrollTop - elementTop + extraOffset + stickyHeight;
+            const maxTop = cell.layoutInfo.editorHeight + cell.layoutInfo.statusBarHeight - 45;
+            const top = maxTop > 20 ?
+                clamp(min, diff, maxTop) :
+                min;
+            element.style.top = `${top}px`;
+        }
+    };
+    updateForScroll();
+    return notebookEditor.onDidScroll(() => updateForScroll());
+}
+export { registerCellToolbarStickyScroll };

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

@@ -0,0 +1,228 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ToolBar } from 'monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MenuEntryActionViewItem, createActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.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 { CodiconActionViewItem } from './cellActionView.js';
+import { CellOverlayPart } from '../cellPart.js';
+import { registerCellToolbarStickyScroll } from './cellToolbarStickyScroll.js';
+import { WorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+let BetweenCellToolbar = class BetweenCellToolbar extends CellOverlayPart {
+    constructor(_notebookEditor, _titleToolbarContainer, _bottomCellToolbarContainer, instantiationService, contextMenuService, contextKeyService, menuService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._bottomCellToolbarContainer = _bottomCellToolbarContainer;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+    }
+    _initialize() {
+        if (this._betweenCellToolbar) {
+            return this._betweenCellToolbar;
+        }
+        const betweenCellToolbar = this._register(( new ToolBar(this._bottomCellToolbarContainer, this.contextMenuService, {
+            actionViewItemProvider: action => {
+                if (action instanceof MenuItemAction) {
+                    if (this._notebookEditor.notebookOptions.getDisplayOptions().insertToolbarAlignment === 'center') {
+                        return this.instantiationService.createInstance(CodiconActionViewItem, action, undefined);
+                    }
+                    else {
+                        return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+                    }
+                }
+                return undefined;
+            }
+        })));
+        this._betweenCellToolbar = betweenCellToolbar;
+        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) => {
+            if (e.insertToolbarAlignment) {
+                updateActions();
+            }
+        }));
+        updateActions();
+        return betweenCellToolbar;
+    }
+    didRenderCell(element) {
+        const betweenCellToolbar = this._initialize();
+        betweenCellToolbar.context = {
+            ui: true,
+            cell: element,
+            notebookEditor: this._notebookEditor,
+            $mid: 13
+        };
+        this.updateInternalLayoutNow(element);
+    }
+    updateInternalLayoutNow(element) {
+        const bottomToolbarOffset = element.layoutInfo.bottomToolbarOffset;
+        this._bottomCellToolbarContainer.style.transform = `translateY(${bottomToolbarOffset}px)`;
+    }
+};
+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;
+    }
+    constructor(toolbarContainer, _rootClassDelegate, toolbarId, deleteToolbarId, _notebookEditor, contextKeyService, menuService, instantiationService) {
+        super();
+        this.toolbarContainer = toolbarContainer;
+        this._rootClassDelegate = _rootClassDelegate;
+        this.toolbarId = toolbarId;
+        this.deleteToolbarId = deleteToolbarId;
+        this._notebookEditor = _notebookEditor;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.instantiationService = instantiationService;
+        this._onDidUpdateActions = this._register(( new Emitter()));
+        this.onDidUpdateActions = this._onDidUpdateActions.event;
+    }
+    _initializeModel() {
+        if (this._model) {
+            return this._model;
+        }
+        const titleMenu = this._register(this.menuService.createMenu(this.toolbarId, this.contextKeyService));
+        const deleteMenu = this._register(this.menuService.createMenu(this.deleteToolbarId, this.contextKeyService));
+        const actions = getCellToolbarActions(titleMenu);
+        const deleteActions = getCellToolbarActions(deleteMenu);
+        this._model = {
+            titleMenu,
+            actions,
+            deleteMenu,
+            deleteActions
+        };
+        return this._model;
+    }
+    _initialize(model, element) {
+        if (this._view) {
+            return this._view;
+        }
+        const toolbar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, {
+            actionViewItemProvider: action => {
+                return createActionViewItem(this.instantiationService, action);
+            },
+            renderDropdownAsChildElement: true
+        }));
+        const deleteToolbar = this._register(this.instantiationService.invokeFunction(accessor => createDeleteToolbar(accessor, this.toolbarContainer, 'cell-delete-toolbar')));
+        if (model.deleteActions.primary.length !== 0 || model.deleteActions.secondary.length !== 0) {
+            deleteToolbar.setActions(model.deleteActions.primary, model.deleteActions.secondary);
+        }
+        this.setupChangeListeners(toolbar, model.titleMenu, model.actions);
+        this.setupChangeListeners(deleteToolbar, model.deleteMenu, model.deleteActions);
+        this._view = {
+            toolbar,
+            deleteToolbar
+        };
+        return this._view;
+    }
+    prepareRenderCell(element) {
+        this._initializeModel();
+    }
+    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.updateContext(view, {
+            ui: true,
+            cell: element,
+            notebookEditor: this._notebookEditor,
+            $mid: 13
+        });
+    }
+    updateContext(view, toolbarContext) {
+        view.toolbar.context = toolbarContext;
+        view.deleteToolbar.context = toolbarContext;
+    }
+    setupChangeListeners(toolbar, menu, initActions) {
+        let dropdownIsVisible = false;
+        let deferredUpdate;
+        this.updateActions(toolbar, initActions);
+        this._register(menu.onDidChange(() => {
+            if (dropdownIsVisible) {
+                const actions = getCellToolbarActions(menu);
+                deferredUpdate = () => this.updateActions(toolbar, actions);
+                return;
+            }
+            const actions = getCellToolbarActions(menu);
+            this.updateActions(toolbar, actions);
+        }));
+        this._rootClassDelegate.toggle('cell-toolbar-dropdown-active', false);
+        this._register(toolbar.onDidChangeDropdownVisibility(visible => {
+            dropdownIsVisible = visible;
+            this._rootClassDelegate.toggle('cell-toolbar-dropdown-active', visible);
+            if (deferredUpdate && !visible) {
+                disposableTimeout(() => {
+                    deferredUpdate?.();
+                }, 0, this._store);
+                deferredUpdate = undefined;
+            }
+        }));
+    }
+    updateActions(toolbar, actions) {
+        const hadFocus = dom.isAncestorOfActiveElement(toolbar.getElement());
+        toolbar.setActions(actions.primary, actions.secondary);
+        if (hadFocus) {
+            this._notebookEditor.focus();
+        }
+        if (actions.primary.length || actions.secondary.length) {
+            this._rootClassDelegate.toggle('cell-has-toolbar-actions', true);
+            this._onDidUpdateActions.fire();
+        }
+        else {
+            this._rootClassDelegate.toggle('cell-has-toolbar-actions', false);
+            this._onDidUpdateActions.fire();
+        }
+    }
+};
+CellTitleToolbarPart = ( __decorate([
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IInstantiationService))
+], CellTitleToolbarPart));
+function getCellToolbarActions(menu) {
+    const primary = [];
+    const secondary = [];
+    const result = { primary, secondary };
+    createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, result, g => /^inline/.test(g));
+    return result;
+}
+function createDeleteToolbar(accessor, container, elementClass) {
+    const contextMenuService = accessor.get(IContextMenuService);
+    const keybindingService = accessor.get(IKeybindingService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const toolbar = ( new ToolBar(container, contextMenuService, {
+        getKeyBinding: action => keybindingService.lookupKeybinding(action.id),
+        actionViewItemProvider: action => {
+            return createActionViewItem(instantiationService, action);
+        },
+        renderDropdownAsChildElement: true
+    }));
+    if (elementClass) {
+        toolbar.getElement().classList.add(elementClass);
+    }
+    return toolbar;
+}
+export { BetweenCellToolbar, CellTitleToolbarPart };