@codingame/monaco-vscode-api 1.85.0 → 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookEditorToolbar.js

@@ -0,0 +1,527 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { ToolBar } from 'monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.js';
+import { Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IMenuService, MenuItemAction, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { SELECT_KERNEL_ID } from '../controller/coreActions.js';
+import { NOTEBOOK_EDITOR_ID, NotebookSetting } from '../../common/notebookCommon.js';
+import { NotebooKernelActionViewItem } from './notebookKernelView.js';
+import { ActionViewWithLabel } from '../view/cellParts/cellActionView.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { IWorkbenchAssignmentService } from '../../../../services/assignment/common/assignmentService.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { WorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+var RenderLabel;
+( (function(RenderLabel) {
+    RenderLabel[RenderLabel["Always"] = 0] = "Always";
+    RenderLabel[RenderLabel["Never"] = 1] = "Never";
+    RenderLabel[RenderLabel["Dynamic"] = 2] = "Dynamic";
+})(RenderLabel || (RenderLabel = {})));
+const ICON_ONLY_ACTION_WIDTH = 21;
+const TOGGLE_MORE_ACTION_WIDTH = 21;
+const ACTION_PADDING = 8;
+class WorkbenchAlwaysLabelStrategy {
+    constructor(notebookEditor, editorToolbar, instantiationService) {
+        this.notebookEditor = notebookEditor;
+        this.editorToolbar = editorToolbar;
+        this.instantiationService = instantiationService;
+    }
+    actionProvider(action) {
+        if (action.id === SELECT_KERNEL_ID) {
+            return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
+        }
+        return action instanceof MenuItemAction ? this.instantiationService.createInstance(ActionViewWithLabel, action, undefined) : undefined;
+    }
+    calculateActions(leftToolbarContainerMaxWidth) {
+        const initialPrimaryActions = this.editorToolbar.primaryActions;
+        const initialSecondaryActions = this.editorToolbar.secondaryActions;
+        const actionOutput = workbenchCalculateActions(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth);
+        return {
+            primaryActions: ( actionOutput.primaryActions.map(a => a.action)),
+            secondaryActions: actionOutput.secondaryActions
+        };
+    }
+}
+class WorkbenchNeverLabelStrategy {
+    constructor(notebookEditor, editorToolbar, instantiationService) {
+        this.notebookEditor = notebookEditor;
+        this.editorToolbar = editorToolbar;
+        this.instantiationService = instantiationService;
+    }
+    actionProvider(action) {
+        if (action.id === SELECT_KERNEL_ID) {
+            return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
+        }
+        return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+    }
+    calculateActions(leftToolbarContainerMaxWidth) {
+        const initialPrimaryActions = this.editorToolbar.primaryActions;
+        const initialSecondaryActions = this.editorToolbar.secondaryActions;
+        const actionOutput = workbenchCalculateActions(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth);
+        return {
+            primaryActions: ( actionOutput.primaryActions.map(a => a.action)),
+            secondaryActions: actionOutput.secondaryActions
+        };
+    }
+}
+class WorkbenchDynamicLabelStrategy {
+    constructor(notebookEditor, editorToolbar, instantiationService) {
+        this.notebookEditor = notebookEditor;
+        this.editorToolbar = editorToolbar;
+        this.instantiationService = instantiationService;
+    }
+    actionProvider(action) {
+        if (action.id === SELECT_KERNEL_ID) {
+            return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
+        }
+        const a = this.editorToolbar.primaryActions.find(a => a.action.id === action.id);
+        if (!a || a.renderLabel) {
+            return action instanceof MenuItemAction ? this.instantiationService.createInstance(ActionViewWithLabel, action, undefined) : undefined;
+        }
+        else {
+            return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+        }
+    }
+    calculateActions(leftToolbarContainerMaxWidth) {
+        const initialPrimaryActions = this.editorToolbar.primaryActions;
+        const initialSecondaryActions = this.editorToolbar.secondaryActions;
+        const actionOutput = workbenchDynamicCalculateActions(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth);
+        return {
+            primaryActions: ( actionOutput.primaryActions.map(a => a.action)),
+            secondaryActions: actionOutput.secondaryActions
+        };
+    }
+}
+let NotebookEditorWorkbenchToolbar = class NotebookEditorWorkbenchToolbar extends Disposable {
+    get primaryActions() {
+        return this._primaryActions;
+    }
+    get secondaryActions() {
+        return this._secondaryActions;
+    }
+    set visible(visible) {
+        if (this._visible !== visible) {
+            this._visible = visible;
+            this._onDidChangeVisibility.fire(visible);
+        }
+    }
+    get useGlobalToolbar() {
+        return this._useGlobalToolbar;
+    }
+    constructor(notebookEditor, contextKeyService, notebookOptions, domNode, instantiationService, configurationService, contextMenuService, menuService, editorService, keybindingService, experimentService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.contextKeyService = contextKeyService;
+        this.notebookOptions = notebookOptions;
+        this.domNode = domNode;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.contextMenuService = contextMenuService;
+        this.menuService = menuService;
+        this.editorService = editorService;
+        this.keybindingService = keybindingService;
+        this.experimentService = experimentService;
+        this._useGlobalToolbar = false;
+        this._renderLabel = RenderLabel.Always;
+        this._visible = false;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._dimension = null;
+        this._primaryActions = [];
+        this._secondaryActions = [];
+        this._buildBody();
+        this._register(Event.debounce(this.editorService.onDidActiveEditorChange, (last, _current) => last, 200)(this._updatePerEditorChange, this));
+        this._registerNotebookActionsToolbar();
+    }
+    _buildBody() {
+        this._notebookTopLeftToolbarContainer = document.createElement('div');
+        this._notebookTopLeftToolbarContainer.classList.add('notebook-toolbar-left');
+        this._leftToolbarScrollable = ( new DomScrollableElement(this._notebookTopLeftToolbarContainer, {
+            vertical: 2 ,
+            horizontal: 3 ,
+            horizontalScrollbarSize: 3,
+            useShadows: false,
+            scrollYToX: true
+        }));
+        this._register(this._leftToolbarScrollable);
+        dom.append(this.domNode, this._leftToolbarScrollable.getDomNode());
+        this._notebookTopRightToolbarContainer = document.createElement('div');
+        this._notebookTopRightToolbarContainer.classList.add('notebook-toolbar-right');
+        dom.append(this.domNode, this._notebookTopRightToolbarContainer);
+    }
+    _updatePerEditorChange() {
+        if (this.editorService.activeEditorPane?.getId() === NOTEBOOK_EDITOR_ID) {
+            const notebookEditor = this.editorService.activeEditorPane.getControl();
+            if (notebookEditor === this.notebookEditor) {
+                this._showNotebookActionsinEditorToolbar();
+                return;
+            }
+        }
+    }
+    _registerNotebookActionsToolbar() {
+        this._notebookGlobalActionsMenu = this._register(this.menuService.createMenu(this.notebookEditor.creationOptions.menuIds.notebookToolbar, this.contextKeyService));
+        this._register(this._notebookGlobalActionsMenu);
+        this._useGlobalToolbar = this.notebookOptions.getDisplayOptions().globalToolbar;
+        this._renderLabel = this._convertConfiguration(this.configurationService.getValue(NotebookSetting.globalToolbarShowLabel));
+        this._updateStrategy();
+        const context = {
+            ui: true,
+            notebookEditor: this.notebookEditor
+        };
+        const actionProvider = (action) => {
+            if (action.id === SELECT_KERNEL_ID) {
+                return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
+            }
+            if (this._renderLabel !== RenderLabel.Never) {
+                const a = this._primaryActions.find(a => a.action.id === action.id);
+                if (a && a.renderLabel) {
+                    return action instanceof MenuItemAction ? this.instantiationService.createInstance(ActionViewWithLabel, action, undefined) : undefined;
+                }
+                else {
+                    return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+                }
+            }
+            else {
+                return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+            }
+        };
+        const leftToolbarOptions = {
+            hiddenItemStrategy: 1 ,
+            resetMenu: MenuId.NotebookToolbar,
+            actionViewItemProvider: (action, options) => {
+                return this._strategy.actionProvider(action, options);
+            },
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            renderDropdownAsChildElement: true,
+        };
+        this._notebookLeftToolbar = this.instantiationService.createInstance(WorkbenchToolBar, this._notebookTopLeftToolbarContainer, leftToolbarOptions);
+        this._register(this._notebookLeftToolbar);
+        this._notebookLeftToolbar.context = context;
+        this._notebookRightToolbar = ( new ToolBar(this._notebookTopRightToolbarContainer, this.contextMenuService, {
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            actionViewItemProvider: actionProvider,
+            renderDropdownAsChildElement: true
+        }));
+        this._register(this._notebookRightToolbar);
+        this._notebookRightToolbar.context = context;
+        this._showNotebookActionsinEditorToolbar();
+        let dropdownIsVisible = false;
+        let deferredUpdate;
+        this._register(this._notebookGlobalActionsMenu.onDidChange(() => {
+            if (dropdownIsVisible) {
+                deferredUpdate = () => this._showNotebookActionsinEditorToolbar();
+                return;
+            }
+            if (this.notebookEditor.isVisible) {
+                this._showNotebookActionsinEditorToolbar();
+            }
+        }));
+        this._register(this._notebookLeftToolbar.onDidChangeDropdownVisibility(visible => {
+            dropdownIsVisible = visible;
+            if (deferredUpdate && !visible) {
+                setTimeout(() => {
+                    deferredUpdate?.();
+                }, 0);
+                deferredUpdate = undefined;
+            }
+        }));
+        this._register(this.notebookOptions.onDidChangeOptions(e => {
+            if (e.globalToolbar !== undefined) {
+                this._useGlobalToolbar = this.notebookOptions.getDisplayOptions().globalToolbar;
+                this._showNotebookActionsinEditorToolbar();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.globalToolbarShowLabel)) {
+                this._renderLabel = this._convertConfiguration(this.configurationService.getValue(NotebookSetting.globalToolbarShowLabel));
+                this._updateStrategy();
+                const oldElement = this._notebookLeftToolbar.getElement();
+                oldElement.parentElement?.removeChild(oldElement);
+                this._notebookLeftToolbar.dispose();
+                this._notebookLeftToolbar = this.instantiationService.createInstance(WorkbenchToolBar, this._notebookTopLeftToolbarContainer, leftToolbarOptions);
+                this._register(this._notebookLeftToolbar);
+                this._notebookLeftToolbar.context = context;
+                this._showNotebookActionsinEditorToolbar();
+                return;
+            }
+        }));
+        if (this.experimentService) {
+            this.experimentService.getTreatment('nbtoolbarineditor').then(treatment => {
+                if (treatment === undefined) {
+                    return;
+                }
+                if (this._useGlobalToolbar !== treatment) {
+                    this._useGlobalToolbar = treatment;
+                    this._showNotebookActionsinEditorToolbar();
+                }
+            });
+        }
+    }
+    _updateStrategy() {
+        switch (this._renderLabel) {
+            case RenderLabel.Always:
+                this._strategy = ( new WorkbenchAlwaysLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                break;
+            case RenderLabel.Never:
+                this._strategy = ( new WorkbenchNeverLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                break;
+            case RenderLabel.Dynamic:
+                this._strategy = ( new WorkbenchDynamicLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                break;
+        }
+    }
+    _convertConfiguration(value) {
+        switch (value) {
+            case true:
+                return RenderLabel.Always;
+            case false:
+                return RenderLabel.Never;
+            case 'always':
+                return RenderLabel.Always;
+            case 'never':
+                return RenderLabel.Never;
+            case 'dynamic':
+                return RenderLabel.Dynamic;
+        }
+    }
+    _showNotebookActionsinEditorToolbar() {
+        if (!this.notebookEditor.hasModel()) {
+            this._deferredActionUpdate?.dispose();
+            this._deferredActionUpdate = undefined;
+            this.visible = false;
+            return;
+        }
+        if (this._deferredActionUpdate) {
+            return;
+        }
+        if (!this._useGlobalToolbar) {
+            this.domNode.style.display = 'none';
+            this._deferredActionUpdate = undefined;
+            this.visible = false;
+        }
+        else {
+            this._deferredActionUpdate = disposableTimeout(async () => {
+                await this._setNotebookActions();
+                this.visible = true;
+                this._deferredActionUpdate = undefined;
+            }, 50);
+        }
+    }
+    async _setNotebookActions() {
+        const groups = this._notebookGlobalActionsMenu.getActions({ shouldForwardArgs: true, renderShortTitle: true });
+        this.domNode.style.display = 'flex';
+        const primaryLeftGroups = groups.filter(group => /^navigation/.test(group[0]));
+        const primaryActions = [];
+        primaryLeftGroups.sort((a, b) => {
+            if (a[0] === 'navigation') {
+                return 1;
+            }
+            if (b[0] === 'navigation') {
+                return -1;
+            }
+            return 0;
+        }).forEach((group, index) => {
+            primaryActions.push(...group[1]);
+            if (index < primaryLeftGroups.length - 1) {
+                primaryActions.push(( new Separator()));
+            }
+        });
+        const primaryRightGroup = groups.find(group => /^status/.test(group[0]));
+        const primaryRightActions = primaryRightGroup ? primaryRightGroup[1] : [];
+        const secondaryActions = groups.filter(group => !/^navigation/.test(group[0]) && !/^status/.test(group[0])).reduce((prev, curr) => { prev.push(...curr[1]); return prev; }, []);
+        this._notebookLeftToolbar.setActions([], []);
+        this._primaryActions = ( primaryActions.map(action => ({
+            action: action,
+            size: (action instanceof Separator ? 1 : 0),
+            renderLabel: true,
+            visible: true
+        })));
+        this._notebookLeftToolbar.setActions(primaryActions, secondaryActions);
+        this._secondaryActions = secondaryActions;
+        this._notebookRightToolbar.setActions(primaryRightActions, []);
+        this._secondaryActions = secondaryActions;
+        if (this._dimension && this._dimension.width >= 0 && this._dimension.height >= 0) {
+            this._cacheItemSizes(this._notebookLeftToolbar);
+        }
+        this._computeSizes();
+    }
+    _cacheItemSizes(toolbar) {
+        for (let i = 0; i < toolbar.getItemsLength(); i++) {
+            const action = toolbar.getItemAction(i);
+            if (action && action.id !== 'toolbar.toggle.more') {
+                const existing = this._primaryActions.find(a => a.action.id === action.id);
+                if (existing) {
+                    existing.size = toolbar.getItemWidth(i);
+                }
+            }
+        }
+    }
+    _computeSizes() {
+        const toolbar = this._notebookLeftToolbar;
+        const rightToolbar = this._notebookRightToolbar;
+        if (toolbar && rightToolbar && this._dimension && this._dimension.height >= 0 && this._dimension.width >= 0) {
+            if (this._primaryActions.length === 0 && toolbar.getItemsLength() !== this._primaryActions.length) {
+                this._cacheItemSizes(this._notebookLeftToolbar);
+            }
+            if (this._primaryActions.length === 0) {
+                return;
+            }
+            const kernelWidth = (rightToolbar.getItemsLength() ? rightToolbar.getItemWidth(0) : 0) + ACTION_PADDING;
+            const leftToolbarContainerMaxWidth = this._dimension.width - kernelWidth - (ACTION_PADDING + TOGGLE_MORE_ACTION_WIDTH) - ( ACTION_PADDING) - ( ACTION_PADDING);
+            const calculatedActions = this._strategy.calculateActions(leftToolbarContainerMaxWidth);
+            this._notebookLeftToolbar.setActions(calculatedActions.primaryActions, calculatedActions.secondaryActions);
+        }
+    }
+    layout(dimension) {
+        this._dimension = dimension;
+        if (!this._useGlobalToolbar) {
+            this.domNode.style.display = 'none';
+        }
+        else {
+            this.domNode.style.display = 'flex';
+        }
+        this._computeSizes();
+    }
+    dispose() {
+        this._notebookLeftToolbar.context = undefined;
+        this._notebookRightToolbar.context = undefined;
+        this._notebookLeftToolbar.dispose();
+        this._notebookRightToolbar.dispose();
+        this._notebookLeftToolbar = null;
+        this._notebookRightToolbar = null;
+        this._deferredActionUpdate?.dispose();
+        this._deferredActionUpdate = undefined;
+        super.dispose();
+    }
+};
+NotebookEditorWorkbenchToolbar = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, IKeybindingService)),
+    ( __param(10, IWorkbenchAssignmentService))
+], NotebookEditorWorkbenchToolbar));
+function workbenchCalculateActions(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth) {
+    return actionOverflowHelper(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth, false);
+}
+function workbenchDynamicCalculateActions(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth) {
+    if (initialPrimaryActions.length === 0) {
+        return { primaryActions: [], secondaryActions: initialSecondaryActions };
+    }
+    const visibleActionLength = initialPrimaryActions.filter(action => action.size !== 0).length;
+    const totalWidthWithLabels = ( initialPrimaryActions.map(action => action.size)).reduce((a, b) => a + b, 0) + (visibleActionLength - 1) * ACTION_PADDING;
+    if (totalWidthWithLabels <= leftToolbarContainerMaxWidth) {
+        initialPrimaryActions.forEach(action => {
+            action.renderLabel = true;
+        });
+        return actionOverflowHelper(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth, false);
+    }
+    if ((visibleActionLength * ICON_ONLY_ACTION_WIDTH + (visibleActionLength - 1) * ACTION_PADDING) > leftToolbarContainerMaxWidth) {
+        initialPrimaryActions.forEach(action => { action.renderLabel = false; });
+        return actionOverflowHelper(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth, true);
+    }
+    let sum = 0;
+    let lastActionWithLabel = -1;
+    for (let i = 0; i < initialPrimaryActions.length; i++) {
+        sum += initialPrimaryActions[i].size + ACTION_PADDING;
+        if (initialPrimaryActions[i].action instanceof Separator) {
+            const remainingItems = initialPrimaryActions.slice(i + 1).filter(action => action.size !== 0);
+            const newTotalSum = sum + (remainingItems.length === 0 ? 0 : (remainingItems.length * ICON_ONLY_ACTION_WIDTH + (remainingItems.length - 1) * ACTION_PADDING));
+            if (newTotalSum <= leftToolbarContainerMaxWidth) {
+                lastActionWithLabel = i;
+            }
+        }
+        else {
+            continue;
+        }
+    }
+    if (lastActionWithLabel < 0) {
+        initialPrimaryActions.forEach(action => { action.renderLabel = false; });
+        return actionOverflowHelper(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth, true);
+    }
+    initialPrimaryActions.slice(0, lastActionWithLabel + 1).forEach(action => { action.renderLabel = true; });
+    initialPrimaryActions.slice(lastActionWithLabel + 1).forEach(action => { action.renderLabel = false; });
+    return {
+        primaryActions: initialPrimaryActions,
+        secondaryActions: initialSecondaryActions
+    };
+}
+function actionOverflowHelper(initialPrimaryActions, initialSecondaryActions, leftToolbarContainerMaxWidth, iconOnly) {
+    const renderActions = [];
+    const overflow = [];
+    let currentSize = 0;
+    let nonZeroAction = false;
+    let containerFull = false;
+    if (initialPrimaryActions.length === 0) {
+        return { primaryActions: [], secondaryActions: initialSecondaryActions };
+    }
+    for (let i = 0; i < initialPrimaryActions.length; i++) {
+        const actionModel = initialPrimaryActions[i];
+        const itemSize = iconOnly ? (actionModel.size === 0 ? 0 : ICON_ONLY_ACTION_WIDTH) : actionModel.size;
+        if (actionModel.action instanceof Separator && renderActions.length > 0 && renderActions[renderActions.length - 1].action instanceof Separator) {
+            continue;
+        }
+        if (actionModel.action instanceof Separator && !nonZeroAction) {
+            continue;
+        }
+        if (currentSize + itemSize <= leftToolbarContainerMaxWidth && !containerFull) {
+            currentSize += ACTION_PADDING + itemSize;
+            renderActions.push(actionModel);
+            if (itemSize !== 0) {
+                nonZeroAction = true;
+            }
+            if (actionModel.action instanceof Separator) {
+                nonZeroAction = false;
+            }
+        }
+        else {
+            containerFull = true;
+            if (itemSize === 0) {
+                renderActions.push(actionModel);
+            }
+            else {
+                if (actionModel.action instanceof Separator) {
+                    continue;
+                }
+                overflow.push(actionModel.action);
+            }
+        }
+    }
+    for (let i = (renderActions.length - 1); i > 0; i--) {
+        const temp = renderActions[i];
+        if (temp.size === 0) {
+            continue;
+        }
+        if (temp.action instanceof Separator) {
+            renderActions.splice(i, 1);
+        }
+        break;
+    }
+    if (renderActions.length && renderActions[renderActions.length - 1].action instanceof Separator) {
+        renderActions.pop();
+    }
+    if (overflow.length !== 0) {
+        overflow.push(( new Separator()));
+    }
+    if (iconOnly) {
+        const markdownIndex = renderActions.findIndex(a => a.action.id === 'notebook.cell.insertMarkdownCellBelow');
+        if (markdownIndex !== -1) {
+            renderActions.splice(markdownIndex, 1);
+        }
+    }
+    return {
+        primaryActions: renderActions,
+        secondaryActions: [...overflow, ...initialSecondaryActions]
+    };
+}
+export { NotebookEditorWorkbenchToolbar, RenderLabel, workbenchCalculateActions, workbenchDynamicCalculateActions };