@codingame/monaco-vscode-api 13.1.7 → 14.0.1

package/vscode/src/vs/platform/accessibility/browser/accessibleView.d.ts

@@ -1,5 +1,5 @@
 import { IKeyboardEvent } from "../../keybinding/common/keybinding.js";
-import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-219d9a5f-b446-507b-a188-1178a0867c75-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
+import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-d0fb86d3-2a47-594e-955b-9a24631a7124-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
 import { Event } from "../../../base/common/event.js";
 import { IAction } from "../../../base/common/actions.js";
 import { IQuickPickItem } from "../../quickinput/common/quickInput.js";
@@ -25,7 +25,8 @@ export declare enum AccessibleViewProviderId {
     Repl = "repl",
     ReplHelp = "replHelp",
     RunAndDebug = "runAndDebug",
-    Walkthrough = "walkthrough"
+    Walkthrough = "walkthrough",
+    SourceControl = "scm"
 }
 export declare enum AccessibleViewType {
     Help = "help",

package/vscode/src/vs/platform/accessibility/browser/accessibleView.js

@@ -24,6 +24,7 @@ var AccessibleViewProviderId;
     AccessibleViewProviderId["ReplHelp"] = "replHelp";
     AccessibleViewProviderId["RunAndDebug"] = "runAndDebug";
     AccessibleViewProviderId["Walkthrough"] = "walkthrough";
+    AccessibleViewProviderId["SourceControl"] = "scm";
 })(AccessibleViewProviderId || (AccessibleViewProviderId = {}));
 var AccessibleViewType;
 (function (AccessibleViewType) {

package/vscode/src/vs/platform/accessibility/browser/accessibleViewRegistry.d.ts

@@ -2,7 +2,7 @@ import { IDisposable } from "../../../base/common/lifecycle.js";
 import { AccessibleViewType, AccessibleContentProvider, ExtensionContentProvider } from "./accessibleView.js";
 import { ContextKeyExpression } from "../../contextkey/common/contextkey.js";
 import { ServicesAccessor } from "../../instantiation/common/instantiation.js";
-export interface IAccessibleViewImplentation {
+export interface IAccessibleViewImplementation {
     type: AccessibleViewType;
     priority: number;
     name: string;
@@ -10,7 +10,7 @@ export interface IAccessibleViewImplentation {
     when?: ContextKeyExpression | undefined;
 }
 export declare const AccessibleViewRegistry: {
-    _implementations: IAccessibleViewImplentation[];
-    register(implementation: IAccessibleViewImplentation): IDisposable;
-    getImplementations(): IAccessibleViewImplentation[];
+    _implementations: IAccessibleViewImplementation[];
+    register(implementation: IAccessibleViewImplementation): IDisposable;
+    getImplementations(): IAccessibleViewImplementation[];
 };

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -263,163 +263,163 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1539, 'Error at Position')),
+        name: ( localize(1575, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1540, 'Error')),
+        announcementMessage: ( localize(1576, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1541, 'Warning at Position')),
+        name: ( localize(1577, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1542, 'Warning')),
+        announcementMessage: ( localize(1578, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1543, 'Error on Line')),
+        name: ( localize(1579, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1544, 'Error on Line')),
+        announcementMessage: ( localize(1580, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1545, 'Warning on Line')),
+        name: ( localize(1581, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1546, 'Warning on Line')),
+        announcementMessage: ( localize(1582, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1547, 'Folded Area on Line')),
+        name: ( localize(1583, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1548, 'Folded')),
+        announcementMessage: ( localize(1584, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1549, 'Breakpoint on Line')),
+        name: ( localize(1585, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1550, 'Breakpoint')),
+        announcementMessage: ( localize(1586, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1551, 'Inline Suggestion on Line')),
+        name: ( localize(1587, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1552, 'Terminal Quick Fix')),
+        name: ( localize(1588, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1553, 'Quick Fix')),
+        announcementMessage: ( localize(1589, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1554, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1590, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1555, 'Breakpoint')),
+        announcementMessage: ( localize(1591, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1556, 'No Inlay Hints on Line')),
+        name: ( localize(1592, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1557, 'No Inlay Hints')),
+        announcementMessage: ( localize(1593, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1558, 'Task Completed')),
+        name: ( localize(1594, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1559, 'Task Completed')),
+        announcementMessage: ( localize(1595, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1560, 'Task Failed')),
+        name: ( localize(1596, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1561, 'Task Failed')),
+        announcementMessage: ( localize(1597, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1562, 'Terminal Command Failed')),
+        name: ( localize(1598, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1563, 'Command Failed')),
+        announcementMessage: ( localize(1599, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1564, 'Terminal Command Succeeded')),
+        name: ( localize(1600, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(1565, 'Command Succeeded')),
+        announcementMessage: ( localize(1601, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1566, 'Terminal Bell')),
+        name: ( localize(1602, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1567, 'Terminal Bell')),
+        announcementMessage: ( localize(1603, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1568, 'Notebook Cell Completed')),
+        name: ( localize(1604, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1569, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1605, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1570, 'Notebook Cell Failed')),
+        name: ( localize(1606, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1571, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1607, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1572, 'Diff Line Inserted')),
+        name: ( localize(1608, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1573, 'Diff Line Deleted')),
+        name: ( localize(1609, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1574, 'Diff Line Modified')),
+        name: ( localize(1610, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1575, 'Chat Request Sent')),
+        name: ( localize(1611, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1576, 'Chat Request Sent')),
+        announcementMessage: ( localize(1612, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1577, 'Chat Response Received')),
+        name: ( localize(1613, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -432,59 +432,59 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1578, 'Code Action Request Triggered')),
+        name: ( localize(1614, 'Code Action Request Triggered')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1579, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1615, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1580, 'Code Action Applied')),
+        name: ( localize(1616, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.voiceRecordingStopped,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1581, 'Progress')),
+        name: ( localize(1617, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1582, 'Progress')),
+        announcementMessage: ( localize(1618, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1583, 'Clear')),
+        name: ( localize(1619, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1584, 'Clear')),
+        announcementMessage: ( localize(1620, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1585, 'Save')),
+        name: ( localize(1621, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1586, 'Save')),
+        announcementMessage: ( localize(1622, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1587, 'Format')),
+        name: ( localize(1623, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1588, 'Format')),
+        announcementMessage: ( localize(1624, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1589, 'Voice Recording Started')),
+        name: ( localize(1625, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1590, 'Voice Recording Stopped')),
+        name: ( localize(1626, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1591, 'View')),
-    Help: ( localize2(1592, 'Help')),
-    Test: ( localize2(1593, 'Test')),
-    File: ( localize2(1594, 'File')),
-    Preferences: ( localize2(1595, 'Preferences')),
-    Developer: ( localize2(1596, "Developer")),
+    View: ( localize2(1627, 'View')),
+    Help: ( localize2(1628, 'Help')),
+    Test: ( localize2(1629, 'Test')),
+    File: ( localize2(1630, 'File')),
+    Preferences: ( localize2(1631, 'Preferences')),
+    Developer: ( localize2(1632, "Developer")),
 }));
 
 export { Categories };

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

@@ -89,10 +89,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localize(1597, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+                data.container.title = ( localize(1633, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localize(1598, "{0} to Apply", actionTitle));
+                data.container.title = ( localize(1634, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -145,13 +145,13 @@ let ActionList = class ActionList extends Disposable {
                     if (element.kind === ActionListItemKind.Action) {
                         let label = element.label ? stripNewlines(element?.label) : '';
                         if (element.disabled) {
-                            label = ( localize(1599, "{0}, Disabled Reason: {1}", label, element.disabled));
+                            label = ( localize(1635, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localize(1600, "Action Widget")),
+                getWidgetAriaLabel: () => ( localize(1636, "Action Widget")),
                 getRole: (e) => e.kind === ActionListItemKind.Action ? 'option' : 'separator',
                 getWidgetRole: () => 'listbox',
             },

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

@@ -26,9 +26,9 @@ import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1601, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1637, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1602, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1638, "Whether the action widget list is visible"))))
 };
 const IActionWidgetService = ( createDecorator('actionWidgetService'));
 let ActionWidgetService = class ActionWidgetService extends Disposable {
@@ -133,7 +133,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(1603, "Hide action widget")),
+            title: ( localize2(1639, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -150,7 +150,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(1604, "Select previous action")),
+            title: ( localize2(1640, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -171,7 +171,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(1605, "Select next action")),
+            title: ( localize2(1641, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -192,7 +192,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1606, "Accept selected action")),
+            title: ( localize2(1642, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -212,7 +212,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1607, "Preview selected action")),
+            title: ( localize2(1643, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

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

@@ -0,0 +1,39 @@
+import { ActionViewItem, BaseActionViewItem } from "../../../base/browser/ui/actionbar/actionViewItems.js";
+import { IAction, IActionRunner } from "../../../base/common/actions.js";
+import { Event } from "../../../base/common/event.js";
+import { ResolvedKeybinding } from "../../../base/common/keybindings.js";
+import { MenuItemAction } from "../common/actions.js";
+import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
+import { IKeybindingService } from "../../keybinding/common/keybinding.service.js";
+import { INotificationService } from "../../notification/common/notification.service.js";
+import { IThemeService } from "../../theme/common/themeService.service.js";
+import { IContextMenuService } from "../../contextview/browser/contextView.service.js";
+import { IAccessibilityService } from "../../accessibility/common/accessibility.service.js";
+import { IHoverDelegate } from "../../../base/browser/ui/hover/hoverDelegate.js";
+export interface IDropdownWithPrimaryActionViewItemOptions {
+    actionRunner?: IActionRunner;
+    getKeyBinding?: (action: IAction) => ResolvedKeybinding | undefined;
+    hoverDelegate?: IHoverDelegate;
+    menuAsChild?: boolean;
+    skipTelemetry?: boolean;
+}
+export declare class DropdownWithPrimaryActionViewItem extends BaseActionViewItem {
+    private readonly _options;
+    private readonly _contextMenuProvider;
+    protected readonly _primaryAction: ActionViewItem;
+    private _dropdown;
+    private _container;
+    private _dropdownContainer;
+    get onDidChangeDropdownVisibility(): Event<boolean>;
+    constructor(primaryAction: MenuItemAction, dropdownAction: IAction, dropdownMenuActions: readonly IAction[], className: string, _options: IDropdownWithPrimaryActionViewItemOptions | undefined, _contextMenuProvider: IContextMenuService, _keybindingService: IKeybindingService, _notificationService: INotificationService, _contextKeyService: IContextKeyService, _themeService: IThemeService, _accessibilityService: IAccessibilityService);
+    set actionRunner(actionRunner: IActionRunner);
+    setActionContext(newContext: unknown): void;
+    render(container: HTMLElement): void;
+    focus(fromRight?: boolean): void;
+    blur(): void;
+    setFocusable(focusable: boolean): void;
+    protected updateEnabled(): void;
+    update(dropdownAction: IAction, dropdownMenuActions: IAction[], dropdownIcon?: string): void;
+    showDropdown(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,145 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { $, append, addDisposableListener, EventType } from '../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { BaseActionViewItem } from '../../../base/browser/ui/actionbar/actionViewItems.js';
+import { DropdownMenuActionViewItem } from '../../../base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { KeyCode } from '../../../base/common/keyCodes.js';
+import { MenuEntryActionViewItem } from './menuEntryActionViewItem.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { INotificationService } from '../../notification/common/notification.service.js';
+import { IThemeService } from '../../theme/common/themeService.service.js';
+import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
+import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
+
+let DropdownWithPrimaryActionViewItem = class DropdownWithPrimaryActionViewItem extends BaseActionViewItem {
+    get onDidChangeDropdownVisibility() {
+        return this._dropdown.onDidChangeVisibility;
+    }
+    constructor(primaryAction, dropdownAction, dropdownMenuActions, className, _options, _contextMenuProvider, _keybindingService, _notificationService, _contextKeyService, _themeService, _accessibilityService) {
+        super(null, primaryAction, { hoverDelegate: _options?.hoverDelegate });
+        this._options = _options;
+        this._contextMenuProvider = _contextMenuProvider;
+        this._container = null;
+        this._dropdownContainer = null;
+        this._primaryAction = ( new MenuEntryActionViewItem(
+            primaryAction,
+            { hoverDelegate: _options?.hoverDelegate },
+            _keybindingService,
+            _notificationService,
+            _contextKeyService,
+            _themeService,
+            _contextMenuProvider,
+            _accessibilityService
+        ));
+        if (_options?.actionRunner) {
+            this._primaryAction.actionRunner = _options.actionRunner;
+        }
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: _options?.menuAsChild ?? true,
+            classNames: className ? ['codicon', 'codicon-chevron-down', className] : ['codicon', 'codicon-chevron-down'],
+            actionRunner: this._options?.actionRunner,
+            keybindingProvider: this._options?.getKeyBinding ?? (action => _keybindingService.lookupKeybinding(action.id)),
+            hoverDelegate: _options?.hoverDelegate,
+            skipTelemetry: _options?.skipTelemetry,
+        }));
+    }
+    set actionRunner(actionRunner) {
+        super.actionRunner = actionRunner;
+        this._primaryAction.actionRunner = actionRunner;
+        this._dropdown.actionRunner = actionRunner;
+    }
+    setActionContext(newContext) {
+        super.setActionContext(newContext);
+        this._primaryAction.setActionContext(newContext);
+        this._dropdown.setActionContext(newContext);
+    }
+    render(container) {
+        this._container = container;
+        super.render(this._container);
+        this._container.classList.add('monaco-dropdown-with-primary');
+        const primaryContainer = $('.action-container');
+        primaryContainer.role = 'button';
+        primaryContainer.ariaDisabled = String(!this.action.enabled);
+        this._primaryAction.render(append(this._container, primaryContainer));
+        this._dropdownContainer = $('.dropdown-action-container');
+        this._dropdown.render(append(this._container, this._dropdownContainer));
+        this._register(addDisposableListener(primaryContainer, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.RightArrow)) {
+                this._primaryAction.element.tabIndex = -1;
+                this._dropdown.focus();
+                event.stopPropagation();
+            }
+        }));
+        this._register(addDisposableListener(this._dropdownContainer, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.LeftArrow)) {
+                this._primaryAction.element.tabIndex = 0;
+                this._dropdown.setFocusable(false);
+                this._primaryAction.element?.focus();
+                event.stopPropagation();
+            }
+        }));
+        this.updateEnabled();
+    }
+    focus(fromRight) {
+        if (fromRight) {
+            this._dropdown.focus();
+        }
+        else {
+            this._primaryAction.element.tabIndex = 0;
+            this._primaryAction.element.focus();
+        }
+    }
+    blur() {
+        this._primaryAction.element.tabIndex = -1;
+        this._dropdown.blur();
+        this._container.blur();
+    }
+    setFocusable(focusable) {
+        if (focusable) {
+            this._primaryAction.element.tabIndex = 0;
+        }
+        else {
+            this._primaryAction.element.tabIndex = -1;
+            this._dropdown.setFocusable(false);
+        }
+    }
+    updateEnabled() {
+        const disabled = !this.action.enabled;
+        this.element?.classList.toggle('disabled', disabled);
+    }
+    update(dropdownAction, dropdownMenuActions, dropdownIcon) {
+        this._dropdown.dispose();
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: true,
+            classNames: ['codicon', dropdownIcon || 'codicon-chevron-down'],
+            actionRunner: this._options?.actionRunner,
+            hoverDelegate: this._options?.hoverDelegate,
+            keybindingProvider: this._options?.getKeyBinding
+        }));
+        if (this._dropdownContainer) {
+            this._dropdown.render(this._dropdownContainer);
+        }
+    }
+    showDropdown() {
+        this._dropdown.show();
+    }
+    dispose() {
+        this._primaryAction.dispose();
+        this._dropdown.dispose();
+        super.dispose();
+    }
+};
+DropdownWithPrimaryActionViewItem = ( __decorate([
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IAccessibilityService))
+], DropdownWithPrimaryActionViewItem));
+
+export { DropdownWithPrimaryActionViewItem };

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

@@ -41,6 +41,7 @@ export interface IMenuEntryActionViewItemOptions {
     draggable?: boolean;
     keybinding?: string;
     hoverDelegate?: IHoverDelegate;
+    keybindingNotRenderedWithLabel?: boolean;
 }
 export declare class MenuEntryActionViewItem<T extends IMenuEntryActionViewItemOptions = IMenuEntryActionViewItemOptions> extends ActionViewItem {
     protected _options: T | undefined;