@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/platform/actionWidget/browser/actionList.js

@@ -23,6 +23,7 @@ import '../../theme/common/colors/minimapColors.js';
 import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
+const _moduleId = "vs/platform/actionWidget/browser/actionList";
 const acceptSelectedActionCommand = 'acceptSelectedCodeAction';
 const previewSelectedActionCommand = 'previewSelectedCodeAction';
 class HeaderRenderer {
@@ -53,7 +54,7 @@ let ActionItemRenderer = class ActionItemRenderer {
         const text = document.createElement('span');
         text.className = 'title';
         container.append(text);
-        const keybinding = ( new KeybindingLabel(container, OS));
+        const keybinding = ( (new KeybindingLabel(container, OS)));
         return { container, icon, text, keybinding };
     }
     renderElement(element, _index, data) {
@@ -81,21 +82,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localizeWithPath(
-                    'vs/platform/actionWidget/browser/actionList',
-                    { key: 'label-preview', comment: ['placeholders are keybindings, e.g "F2 to Apply, Shift+F2 to Preview"'] },
-                    "{0} to Apply, {1} to Preview",
-                    actionTitle,
-                    previewTitle
-                ));
+                data.container.title = ( localizeWithPath(_moduleId, 0, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localizeWithPath(
-                    'vs/platform/actionWidget/browser/actionList',
-                    { key: 'label', comment: ['placeholder is a keybinding, e.g "F2 to Apply"'] },
-                    "{0} to Apply",
-                    actionTitle
-                ));
+                data.container.title = ( localizeWithPath(_moduleId, 1, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -106,9 +96,9 @@ let ActionItemRenderer = class ActionItemRenderer {
         _templateData.keybinding.dispose();
     }
 };
-ActionItemRenderer = ( __decorate([
-    ( __param(1, IKeybindingService))
-], ActionItemRenderer));
+ActionItemRenderer = ( (__decorate([
+    ( (__param(1, IKeybindingService)))
+], ActionItemRenderer)));
 class AcceptSelectedEvent extends UIEvent {
     constructor() { super('acceptSelectedAction'); }
 }
@@ -129,16 +119,16 @@ let ActionList = class ActionList extends Disposable {
         this._keybindingService = _keybindingService;
         this._actionLineHeight = 24;
         this._headerLineHeight = 26;
-        this.cts = this._register(( new CancellationTokenSource()));
+        this.cts = this._register(( (new CancellationTokenSource())));
         this.domNode = document.createElement('div');
         this.domNode.classList.add('actionList');
         const virtualDelegate = {
             getHeight: element => element.kind === "header"  ? this._headerLineHeight : this._actionLineHeight,
             getTemplateId: element => element.kind
         };
-        this._list = this._register(( new List(user, this.domNode, virtualDelegate, [
-            ( new ActionItemRenderer(preview, this._keybindingService)),
-            ( new HeaderRenderer()),
+        this._list = this._register(( (new List(user, this.domNode, virtualDelegate, [
+            ( (new ActionItemRenderer(preview, this._keybindingService))),
+            ( (new HeaderRenderer())),
         ], {
             keyboardSupport: false,
             typeNavigationEnabled: true,
@@ -148,27 +138,17 @@ let ActionList = class ActionList extends Disposable {
                     if (element.kind === "action" ) {
                         let label = element.label ? stripNewlines(element?.label) : '';
                         if (element.disabled) {
-                            label = ( localizeWithPath(
-                                'vs/platform/actionWidget/browser/actionList',
-                                { key: 'customQuickFixWidget.labels', comment: [`Action widget labels for accessibility.`] },
-                                "{0}, Disabled Reason: {1}",
-                                label,
-                                element.disabled
-                            ));
+                            label = ( localizeWithPath(_moduleId, 2, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localizeWithPath(
-                    'vs/platform/actionWidget/browser/actionList',
-                    { key: 'customQuickFixWidget', comment: [`An action widget option`] },
-                    "Action Widget"
-                )),
+                getWidgetAriaLabel: () => ( localizeWithPath(_moduleId, 3, "Action Widget")),
                 getRole: (e) => e.kind === "action"  ? 'option' : 'separator',
                 getWidgetRole: () => 'listbox',
             },
-        })));
+        }))));
         this._list.style(defaultListStyles);
         this._register(this._list.onMouseClick(e => this.onListClick(e)));
         this._register(this._list.onMouseOver(e => this.onListHover(e)));
@@ -198,7 +178,7 @@ let ActionList = class ActionList extends Disposable {
             maxWidth = 380;
         }
         else {
-            const itemWidths = ( this._allMenuItems.map((_, index) => {
+            const itemWidths = ( (this._allMenuItems.map((_, index) => {
                 const element = this.domNode.ownerDocument.getElementById(this._list.getElementID(index));
                 if (element) {
                     element.style.width = 'auto';
@@ -207,7 +187,7 @@ let ActionList = class ActionList extends Disposable {
                     return width;
                 }
                 return 0;
-            }));
+            })));
             maxWidth = Math.max(...itemWidths, minWidth);
         }
         const maxVhPrecentage = 0.7;
@@ -233,7 +213,7 @@ let ActionList = class ActionList extends Disposable {
         if (!this.focusCondition(element)) {
             return;
         }
-        const event = preview ? ( new PreviewSelectedEvent()) : ( new AcceptSelectedEvent());
+        const event = preview ? ( (new PreviewSelectedEvent())) : ( (new AcceptSelectedEvent()));
         this._list.setSelection([focusIndex], event);
     }
     onListSelection(e) {
@@ -276,10 +256,10 @@ let ActionList = class ActionList extends Disposable {
         }
     }
 };
-ActionList = ( __decorate([
-    ( __param(4, IContextViewService)),
-    ( __param(5, IKeybindingService))
-], ActionList));
+ActionList = ( (__decorate([
+    ( (__param(4, IContextViewService))),
+    ( (__param(5, IKeybindingService)))
+], ActionList)));
 function stripNewlines(str) {
     return str.replace(/\r\n|\r|\n/g, ' ');
 }

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -22,19 +22,12 @@ import '../../theme/common/colors/minimapColors.js';
 import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
-registerColor('actionBar.toggledBackground', { dark: inputActiveOptionBackground, light: inputActiveOptionBackground, hcDark: inputActiveOptionBackground, hcLight: inputActiveOptionBackground, }, ( localizeWithPath(
-    'vs/platform/actionWidget/browser/actionWidget',
-    'actionBar.toggledBackground',
-    'Background color for toggled action items in action bar.'
-)));
+const _moduleId = "vs/platform/actionWidget/browser/actionWidget";
+registerColor('actionBar.toggledBackground', { dark: inputActiveOptionBackground, light: inputActiveOptionBackground, hcDark: inputActiveOptionBackground, hcLight: inputActiveOptionBackground, }, ( localizeWithPath(_moduleId, 0, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localizeWithPath(
-        'vs/platform/actionWidget/browser/actionWidget',
-        'codeActionMenuVisible',
-        "Whether the action widget list is visible"
-    ))))
+    Visible: ( (new RawContextKey('codeActionMenuVisible', false, ( localizeWithPath(_moduleId, 1, "Whether the action widget list is visible")))))
 };
-const IActionWidgetService = ( createDecorator('actionWidgetService'));
+const IActionWidgetService = ( (createDecorator('actionWidgetService')));
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
         return ActionWidgetContextKeys.Visible.getValue(this._contextKeyService) || false;
@@ -44,7 +37,7 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         this._contextViewService = _contextViewService;
         this._contextKeyService = _contextKeyService;
         this._instantiationService = _instantiationService;
-        this._list = this._register(( new MutableDisposable()));
+        this._list = this._register(( (new MutableDisposable())));
     }
     show(user, supportsPreview, items, delegate, anchor, container, actionBarActions) {
         const visibleContext = ActionWidgetContextKeys.Visible.bindTo(this._contextKeyService);
@@ -86,9 +79,9 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
             widget.appendChild(this._list.value.domNode);
         }
         else {
-            throw new Error('List has no value');
+            throw ( (new Error('List has no value')));
         }
-        const renderDisposables = ( new DisposableStore());
+        const renderDisposables = ( (new DisposableStore()));
         const menuBlock = document.createElement('div');
         const block = element.appendChild(menuBlock);
         block.classList.add('context-view-block');
@@ -118,7 +111,7 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
             return undefined;
         }
         const container = $(className);
-        const actionBar = ( new ActionBar(container));
+        const actionBar = ( (new ActionBar(container)));
         actionBar.push(actions, { icon: false, label: true });
         return actionBar;
     }
@@ -126,22 +119,18 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         this._list.value?.hide(didCancel);
     }
 };
-ActionWidgetService = ( __decorate([
-    ( __param(0, IContextViewService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IInstantiationService))
-], ActionWidgetService));
+ActionWidgetService = ( (__decorate([
+    ( (__param(0, IContextViewService))),
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IInstantiationService)))
+], ActionWidgetService)));
 registerSingleton(IActionWidgetService, ActionWidgetService, 1 );
 const weight = 100  + 1000;
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2WithPath(
-                'vs/platform/actionWidget/browser/actionWidget',
-                'hideCodeActionWidget.title',
-                "Hide action widget"
-            )),
+            title: ( localize2WithPath(_moduleId, 2, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -158,11 +147,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2WithPath(
-                'vs/platform/actionWidget/browser/actionWidget',
-                'selectPrevCodeAction.title',
-                "Select previous action"
-            )),
+            title: ( localize2WithPath(_moduleId, 3, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -183,11 +168,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2WithPath(
-                'vs/platform/actionWidget/browser/actionWidget',
-                'selectNextCodeAction.title',
-                "Select next action"
-            )),
+            title: ( localize2WithPath(_moduleId, 4, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -208,11 +189,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2WithPath(
-                'vs/platform/actionWidget/browser/actionWidget',
-                'acceptSelected.title',
-                "Accept selected action"
-            )),
+            title: ( localize2WithPath(_moduleId, 5, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -232,11 +209,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2WithPath(
-                'vs/platform/actionWidget/browser/actionWidget',
-                'previewSelected.title',
-                "Preview selected action"
-            )),
+            title: ( localize2WithPath(_moduleId, 6, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actions/browser/buttonbar.js

@@ -13,17 +13,18 @@ import { IContextKeyService } from '../../contextkey/common/contextkey.service.j
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+const _moduleId = "vs/platform/actions/browser/buttonbar";
 let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
     constructor(container, _options, _contextMenuService, _keybindingService, telemetryService) {
         super(container);
         this._options = _options;
         this._contextMenuService = _contextMenuService;
         this._keybindingService = _keybindingService;
-        this._store = ( new DisposableStore());
-        this._updateStore = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
+        this._store = ( (new DisposableStore()));
+        this._updateStore = ( (new DisposableStore()));
+        this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this._actionRunner = this._store.add(( new ActionRunner()));
+        this._actionRunner = this._store.add(( (new ActionRunner())));
         if (_options?.telemetrySource) {
             this._actionRunner.onDidRun(e => {
                 telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: _options.telemetrySource });
@@ -83,13 +84,7 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
             const kb = this._keybindingService.lookupKeybinding(action.id);
             let tooltip;
             if (kb) {
-                tooltip = ( localizeWithPath(
-                    'vs/platform/actions/browser/buttonbar',
-                    'labelWithKeybinding',
-                    "{0} ({1})",
-                    action.label,
-                    kb.getLabel()
-                ));
+                tooltip = ( localizeWithPath(_moduleId, 0, "{0} ({1})", action.label, kb.getLabel()));
             }
             else {
                 tooltip = action.label;
@@ -102,11 +97,11 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
         this._onDidChange.fire(this);
     }
 };
-WorkbenchButtonBar = ( __decorate([
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, ITelemetryService))
-], WorkbenchButtonBar));
+WorkbenchButtonBar = ( (__decorate([
+    ( (__param(2, IContextMenuService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, ITelemetryService)))
+], WorkbenchButtonBar)));
 let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
     constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
         super(container, options, contextMenuService, keybindingService, telemetryService);
@@ -126,14 +121,14 @@ let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButto
         super.dispose();
     }
     update(_actions) {
-        throw new Error('Use Menu or WorkbenchButtonBar');
+        throw ( (new Error('Use Menu or WorkbenchButtonBar')));
     }
 };
-MenuWorkbenchButtonBar = ( __decorate([
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, ITelemetryService))
-], MenuWorkbenchButtonBar));
+MenuWorkbenchButtonBar = ( (__decorate([
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IKeybindingService))),
+    ( (__param(7, ITelemetryService)))
+], MenuWorkbenchButtonBar)));
 export { MenuWorkbenchButtonBar, WorkbenchButtonBar };

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -35,6 +35,7 @@ import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 import { defaultSelectBoxStyles } from '../../theme/browser/defaultStyles.js';
 import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
+const _moduleId = "vs/platform/actions/browser/menuEntryActionViewItem";
 function createAndFillInContextMenuActions(menu, options, target, primaryGroup) {
     const groups = menu.getActions(options);
     const modifierKeyEmitter = ModifierKeyEmitter.getInstance();
@@ -57,19 +58,19 @@ function fillInActions(groups, target, useAlternativeActions, isPrimaryAction =
         primaryBucket = target.primary;
         secondaryBucket = target.secondary;
     }
-    const submenuInfo = ( new Set());
+    const submenuInfo = ( (new Set()));
     for (const [group, actions] of groups) {
         let target;
         if (isPrimaryAction(group)) {
             target = primaryBucket;
             if (target.length > 0 && useSeparatorsInPrimaryActions) {
-                target.push(( new Separator()));
+                target.push(( (new Separator())));
             }
         }
         else {
             target = secondaryBucket;
             if (target.length > 0) {
-                target.push(( new Separator()));
+                target.push(( (new Separator())));
             }
         }
         for (let action of actions) {
@@ -100,7 +101,7 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         this._contextMenuService = _contextMenuService;
         this._accessibilityService = _accessibilityService;
         this._wantsAltCommand = false;
-        this._itemClassDispose = this._register(( new MutableDisposable()));
+        this._itemClassDispose = this._register(( (new MutableDisposable())));
         this._altKey = ModifierKeyEmitter.getInstance();
     }
     get _menuItemAction() {
@@ -160,30 +161,18 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localizeWithPath(
-            'vs/platform/actions/browser/menuEntryActionViewItem',
-            'titleAndKb',
-            "{0} ({1})",
-            tooltip,
-            keybindingLabel
-        ))
+            ? ( localizeWithPath(_moduleId, 0, "{0} ({1})", tooltip, keybindingLabel))
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? ( localizeWithPath(
-                'vs/platform/actions/browser/menuEntryActionViewItem',
-                'titleAndKb',
-                "{0} ({1})",
-                altTooltip,
-                altKeybindingLabel
-            ))
+                ? ( localizeWithPath(_moduleId, 0, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localizeWithPath(
-                'vs/platform/actions/browser/menuEntryActionViewItem',
-                'titleAndKbAndAlt',
+                _moduleId,
+                1,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -235,14 +224,14 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         }
     }
 };
-MenuEntryActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IAccessibilityService))
-], MenuEntryActionViewItem));
+MenuEntryActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IAccessibilityService)))
+], MenuEntryActionViewItem)));
 let SubmenuEntryActionViewItem = class SubmenuEntryActionViewItem extends DropdownMenuActionViewItem {
     constructor(action, options, _keybindingService, _contextMenuService, _themeService) {
         const dropdownOptions = {
@@ -278,11 +267,11 @@ let SubmenuEntryActionViewItem = class SubmenuEntryActionViewItem extends Dropdo
         }
     }
 };
-SubmenuEntryActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IThemeService))
-], SubmenuEntryActionViewItem));
+SubmenuEntryActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, IContextMenuService))),
+    ( (__param(4, IThemeService)))
+], SubmenuEntryActionViewItem)));
 let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem extends BaseActionViewItem {
     get onDidChangeDropdownVisibility() {
         return this._dropdown.onDidChangeVisibility;
@@ -312,14 +301,14 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
             ...options,
             menuAsChild: options?.menuAsChild ?? true,
             classNames: options?.classNames ?? ['codicon', 'codicon-chevron-down'],
-            actionRunner: options?.actionRunner ?? ( new ActionRunner()),
+            actionRunner: options?.actionRunner ?? ( (new ActionRunner())),
         };
-        this._dropdown = ( new DropdownMenuActionViewItem(
+        this._dropdown = ( (new DropdownMenuActionViewItem(
             submenuAction,
             submenuAction.actions,
             this._contextMenuService,
             dropdownOptions
-        ));
+        )));
         this._register(this._dropdown.actionRunner.onDidRun((e) => {
             if (e.action instanceof MenuItemAction) {
                 this.update(e.action);
@@ -363,7 +352,7 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         const primaryContainer = $('.action-container');
         this._defaultAction.render(append(this._container, primaryContainer));
         this._register(addDisposableListener(primaryContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(17 )) {
                 this._defaultAction.element.tabIndex = -1;
                 this._dropdown.focus();
@@ -373,7 +362,7 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         const dropdownContainer = $('.dropdown-action-container');
         this._dropdown.render(append(this._container, dropdownContainer));
         this._register(addDisposableListener(dropdownContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(15 )) {
                 this._defaultAction.element.tabIndex = 0;
                 this._dropdown.setFocusable(false);
@@ -411,20 +400,20 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         super.dispose();
     }
 };
-DropdownWithDefaultActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IMenuService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IStorageService))
-], DropdownWithDefaultActionViewItem));
+DropdownWithDefaultActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IMenuService))),
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IStorageService)))
+], DropdownWithDefaultActionViewItem)));
 let SubmenuEntrySelectActionViewItem = class SubmenuEntrySelectActionViewItem extends SelectActionViewItem {
     constructor(action, contextViewService) {
-        super(null, action, ( action.actions.map(a => ({
+        super(null, action, ( (action.actions.map(a => ({
             text: a.id === Separator.ID ? '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500' : a.label,
             isDisabled: !a.enabled,
-        }))), 0, contextViewService, defaultSelectBoxStyles, { ariaLabel: action.tooltip, optionsAsChildren: true });
+        })))), 0, contextViewService, defaultSelectBoxStyles, { ariaLabel: action.tooltip, optionsAsChildren: true });
         this.select(Math.max(0, action.actions.findIndex(a => a.checked)));
     }
     render(container) {
@@ -438,9 +427,9 @@ let SubmenuEntrySelectActionViewItem = class SubmenuEntrySelectActionViewItem ex
         }
     }
 };
-SubmenuEntrySelectActionViewItem = ( __decorate([
-    ( __param(1, IContextViewService))
-], SubmenuEntrySelectActionViewItem));
+SubmenuEntrySelectActionViewItem = ( (__decorate([
+    ( (__param(1, IContextViewService)))
+], SubmenuEntrySelectActionViewItem)));
 function createActionViewItem(instaService, action, options) {
     if (action instanceof MenuItemAction) {
         return instaService.createInstance(MenuEntryActionViewItem, action, options);

package/vscode/src/vs/platform/actions/browser/toolbar.d.ts

@@ -0,0 +1,73 @@
+import { ToolBar, IToolBarOptions } from '../../../base/browser/ui/toolbar/toolbar.js';
+import { IAction } from '../../../base/common/actions.js';
+import { MenuId, IMenuActionOptions } from '../common/actions.js';
+import { IMenuService } from '../common/actions.service.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
+import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+
+declare const enum HiddenItemStrategy {
+    /** This toolbar doesn't support hiding*/
+    NoHide = -1,
+    /** Hidden items aren't shown anywhere */
+    Ignore = 0,
+    /** Hidden items move into the secondary group */
+    RenderInSecondaryGroup = 1
+}
+type IWorkbenchToolBarOptions = IToolBarOptions & {
+    /**
+     * Items of the primary group can be hidden. When this happens the item can
+     * - move into the secondary popup-menu, or
+     * - not be shown at all
+     */
+    hiddenItemStrategy?: HiddenItemStrategy;
+    /**
+     * Optional menu id which is used for a "Reset Menu" command. This should be the
+     * menu id that defines the contents of this workbench menu
+     */
+    resetMenu?: MenuId;
+    /**
+     * Optional menu id which items are used for the context menu of the toolbar.
+     */
+    contextMenu?: MenuId;
+    /**
+     * Optional options how menu actions are created and invoked
+     */
+    menuOptions?: IMenuActionOptions;
+    /**
+     * When set the `workbenchActionExecuted` is automatically send for each invoked action. The `from` property
+     * of the event will the passed `telemetrySource`-value
+     */
+    telemetrySource?: string;
+    /** This is controlled by the WorkbenchToolBar */
+    allowContextMenu?: never;
+    /**
+     * Controls the overflow behavior of the primary group of toolbar. This isthe maximum number of items and id of
+     * items that should never overflow
+     *
+     */
+    overflowBehavior?: {
+        maxItems: number;
+        exempted?: string[];
+    };
+};
+/**
+ * The `WorkbenchToolBar` does
+ * - support hiding of menu items
+ * - lookup keybindings for each actions automatically
+ * - send `workbenchActionExecuted`-events for each action
+ *
+ * See {@link MenuWorkbenchToolBar} for a toolbar that is backed by a menu.
+ */
+declare class WorkbenchToolBar extends ToolBar {
+    private _options;
+    private readonly _menuService;
+    private readonly _contextKeyService;
+    private readonly _contextMenuService;
+    private readonly _sessionDisposables;
+    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    setActions(_primary: readonly IAction[], _secondary?: readonly IAction[], menuIds?: readonly MenuId[]): void;
+}
+
+export { HiddenItemStrategy, type IWorkbenchToolBarOptions, WorkbenchToolBar };