@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -10,8 +10,9 @@ import { IAccessibilityService } from '../../accessibility/common/accessibility.
 import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { observableConfigValue } from '../../observable/common/platformObservableUtils.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
-import { observableFromEvent, ValueWithChangeEventFromObservable } from '../../../base/common/observableInternal/utils.js';
-import { derived } from '../../../base/common/observableInternal/derived.js';
+import { ValueWithChangeEventFromObservable } from '../../../base/common/observableInternal/utils/valueWithChangeEvent.js';
+import { observableFromEvent } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derived } from '../../../base/common/observableInternal/observables/derived.js';
 
 const AcknowledgeDocCommentsToken = Symbol('AcknowledgeDocCommentsToken');
 let AccessibilitySignalService = class AccessibilitySignalService extends Disposable {
@@ -31,7 +32,7 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
             return derived(reader => {
                 const setting = this._signalConfigValue.get(arg.signal).read(reader);
                 if (arg.modality === 'sound' || arg.modality === undefined) {
-                    if (checkEnabledState(setting.sound, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
+                    if (arg.signal.managesOwnEnablement || checkEnabledState(setting.sound, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
                         return true;
                     }
                 }
@@ -49,7 +50,7 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
     }
     async playSignal(signal, options = {}) {
         const shouldPlayAnnouncement = options.modality === 'announcement' || options.modality === undefined;
-        const announcementMessage = signal.announcementMessage;
+        const announcementMessage = options.customAlertMessage ?? signal.announcementMessage;
         if (shouldPlayAnnouncement && this.isAnnouncementEnabled(signal, options.userGesture) && announcementMessage) {
             this.accessibilityService.status(announcementMessage);
         }
@@ -219,6 +220,9 @@ class Sound {
     static { this.editsUndone = Sound.register({ fileName: 'editsUndone.mp3' }); }
     static { this.nextEditSuggestion = Sound.register({ fileName: 'nextEditSuggestion.mp3' }); }
     static { this.terminalCommandSucceeded = Sound.register({ fileName: 'terminalCommandSucceeded.mp3' }); }
+    static { this.chatUserActionRequired = Sound.register({ fileName: 'chatUserActionRequired.mp3' }); }
+    static { this.codeActionTriggered = Sound.register({ fileName: 'codeActionTriggered.mp3' }); }
+    static { this.codeActionApplied = Sound.register({ fileName: 'codeActionApplied.mp3' }); }
     constructor(fileName) {
         this.fileName = fileName;
     }
@@ -238,13 +242,14 @@ class SoundSource {
     }
 }
 class AccessibilitySignal {
-    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage) {
+    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage, managesOwnEnablement = false) {
         this.sound = sound;
         this.name = name;
         this.legacySoundSettingsKey = legacySoundSettingsKey;
         this.settingsKey = settingsKey;
         this.legacyAnnouncementSettingsKey = legacyAnnouncementSettingsKey;
         this.announcementMessage = announcementMessage;
+        this.managesOwnEnablement = managesOwnEnablement;
     }
     static { this._signals = ( new Set()); }
     static register(options) {
@@ -257,7 +262,8 @@ class AccessibilitySignal {
             options.legacySoundSettingsKey,
             options.settingsKey,
             options.legacyAnnouncementSettingsKey,
-            options.announcementMessage
+            options.announcementMessage,
+            options.managesOwnEnablement
         ));
         AccessibilitySignal._signals.add(signal);
         return signal;
@@ -266,176 +272,176 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1620, 'Error at Position')),
+        name: ( localize(1623, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1621, 'Error')),
+        announcementMessage: ( localize(1624, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1622, 'Warning at Position')),
+        name: ( localize(1625, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1623, 'Warning')),
+        announcementMessage: ( localize(1626, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1624, 'Error on Line')),
+        name: ( localize(1627, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1625, 'Error on Line')),
+        announcementMessage: ( localize(1628, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1626, 'Warning on Line')),
+        name: ( localize(1629, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1627, 'Warning on Line')),
+        announcementMessage: ( localize(1630, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1628, 'Folded Area on Line')),
+        name: ( localize(1631, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1629, 'Folded')),
+        announcementMessage: ( localize(1632, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1630, 'Breakpoint on Line')),
+        name: ( localize(1633, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1631, 'Breakpoint')),
+        announcementMessage: ( localize(1634, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1632, 'Inline Suggestion on Line')),
+        name: ( localize(1635, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.nextEditSuggestion = AccessibilitySignal.register({
-        name: ( localize(1633, 'Next Edit Suggestion on Line')),
+        name: ( localize(1636, 'Next Edit Suggestion on Line')),
         sound: Sound.nextEditSuggestion,
         legacySoundSettingsKey: 'audioCues.nextEditSuggestion',
         settingsKey: 'accessibility.signals.nextEditSuggestion',
-        announcementMessage: ( localize(1634, 'Next Edit Suggestion')),
+        announcementMessage: ( localize(1637, 'Next Edit Suggestion')),
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1635, 'Terminal Quick Fix')),
+        name: ( localize(1638, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1636, 'Quick Fix')),
+        announcementMessage: ( localize(1639, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1637, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1640, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1638, 'Breakpoint')),
+        announcementMessage: ( localize(1641, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1639, 'No Inlay Hints on Line')),
+        name: ( localize(1642, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1640, 'No Inlay Hints')),
+        announcementMessage: ( localize(1643, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1641, 'Task Completed')),
+        name: ( localize(1644, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1642, 'Task Completed')),
+        announcementMessage: ( localize(1645, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1643, 'Task Failed')),
+        name: ( localize(1646, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1644, 'Task Failed')),
+        announcementMessage: ( localize(1647, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1645, 'Terminal Command Failed')),
+        name: ( localize(1648, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1646, 'Command Failed')),
+        announcementMessage: ( localize(1649, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1647, 'Terminal Command Succeeded')),
+        name: ( localize(1650, 'Terminal Command Succeeded')),
         sound: Sound.terminalCommandSucceeded,
-        announcementMessage: ( localize(1648, 'Command Succeeded')),
+        announcementMessage: ( localize(1651, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1649, 'Terminal Bell')),
+        name: ( localize(1652, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1650, 'Terminal Bell')),
+        announcementMessage: ( localize(1653, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1651, 'Notebook Cell Completed')),
+        name: ( localize(1654, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1652, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1655, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1653, 'Notebook Cell Failed')),
+        name: ( localize(1656, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1654, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1657, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1655, 'Diff Line Inserted')),
+        name: ( localize(1658, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1656, 'Diff Line Deleted')),
+        name: ( localize(1659, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1657, 'Diff Line Modified')),
+        name: ( localize(1660, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1658, 'Chat Edit Modified File')),
+        name: ( localize(1661, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1659, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1662, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1660, 'Chat Request Sent')),
+        name: ( localize(1663, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1661, 'Chat Request Sent')),
+        announcementMessage: ( localize(1664, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1662, 'Chat Response Received')),
+        name: ( localize(1665, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -448,75 +454,82 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1663, 'Code Action Request Triggered')),
-        sound: Sound.voiceRecordingStarted,
+        name: ( localize(1666, 'Code Action Request Triggered')),
+        sound: Sound.codeActionTriggered,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1664, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1667, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1665, 'Code Action Applied')),
+        name: ( localize(1668, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
-        sound: Sound.voiceRecordingStopped,
+        sound: Sound.codeActionApplied,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1666, 'Progress')),
+        name: ( localize(1669, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1667, 'Progress')),
+        announcementMessage: ( localize(1670, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1668, 'Clear')),
+        name: ( localize(1671, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1669, 'Clear')),
+        announcementMessage: ( localize(1672, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1670, 'Save')),
+        name: ( localize(1673, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1671, 'Save')),
+        announcementMessage: ( localize(1674, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1672, 'Format')),
+        name: ( localize(1675, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1673, 'Format')),
+        announcementMessage: ( localize(1676, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1674, 'Voice Recording Started')),
+        name: ( localize(1677, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1675, 'Voice Recording Stopped')),
+        name: ( localize(1678, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
     static { this.editsKept = AccessibilitySignal.register({
-        name: ( localize(1676, 'Edits Kept')),
+        name: ( localize(1679, 'Edits Kept')),
         sound: Sound.editsKept,
-        announcementMessage: ( localize(1677, 'Edits Kept')),
+        announcementMessage: ( localize(1680, 'Edits Kept')),
         settingsKey: 'accessibility.signals.editsKept',
     }); }
     static { this.editsUndone = AccessibilitySignal.register({
-        name: ( localize(1678, 'Undo Edits')),
+        name: ( localize(1681, 'Undo Edits')),
         sound: Sound.editsUndone,
-        announcementMessage: ( localize(1679, 'Edits Undone')),
+        announcementMessage: ( localize(1682, 'Edits Undone')),
         settingsKey: 'accessibility.signals.editsUndone',
     }); }
+    static { this.chatUserActionRequired = AccessibilitySignal.register({
+        name: ( localize(1683, 'Chat User Action Required')),
+        sound: Sound.chatUserActionRequired,
+        announcementMessage: ( localize(1684, 'Chat User Action Required')),
+        settingsKey: 'accessibility.signals.chatUserActionRequired',
+        managesOwnEnablement: true
+    }); }
 }
 
 export { AccessibilitySignal, AccessibilitySignalService, AcknowledgeDocCommentsToken, Sound, SoundSource };

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

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1680, 'View')),
-    Help: ( localize2(1681, 'Help')),
-    Test: ( localize2(1682, 'Test')),
-    File: ( localize2(1683, 'File')),
-    Preferences: ( localize2(1684, 'Preferences')),
-    Developer: ( localize2(1685, "Developer")),
+    View: ( localize2(1685, 'View')),
+    Help: ( localize2(1686, 'Help')),
+    Test: ( localize2(1687, 'Test')),
+    File: ( localize2(1688, 'File')),
+    Preferences: ( localize2(1689, 'Preferences')),
+    Developer: ( localize2(1690, "Developer")),
 }));
 
 export { Categories };

package/vscode/src/vs/platform/actionWidget/browser/actionList.d.ts

@@ -1,3 +1,4 @@
+import { IListAccessibilityProvider } from "../../../base/browser/ui/list/listWidget.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { ResolvedKeybinding } from "../../../base/common/keybindings.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
@@ -46,7 +47,7 @@ export declare class ActionList<T> extends Disposable {
     private readonly _headerLineHeight;
     private readonly _allMenuItems;
     private readonly cts;
-    constructor(user: string, preview: boolean, items: readonly IActionListItem<T>[], _delegate: IActionListDelegate<T>, _contextViewService: IContextViewService, _keybindingService: IKeybindingService, _layoutService: ILayoutService);
+    constructor(user: string, preview: boolean, items: readonly IActionListItem<T>[], _delegate: IActionListDelegate<T>, accessibilityProvider: Partial<IListAccessibilityProvider<IActionListItem<T>>> | undefined, _contextViewService: IContextViewService, _keybindingService: IKeybindingService, _layoutService: ILayoutService);
     private focusCondition;
     hide(didCancel?: boolean): void;
     layout(minWidth: number): number;

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

@@ -85,7 +85,12 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         setVisibility(!element.hideIcon, data.icon);
         data.text.textContent = stripNewlines(element.label);
-        if (element.description) {
+        if (element.keybinding) {
+            data.description.textContent = element.keybinding.getLabel();
+            data.description.style.display = 'inline';
+            data.description.style.letterSpacing = '0.5px';
+        }
+        else if (element.description) {
             data.description.textContent = stripNewlines(element.description);
             data.description.style.display = 'inline';
         }
@@ -93,8 +98,6 @@ let ActionItemRenderer = class ActionItemRenderer {
             data.description.textContent = '';
             data.description.style.display = 'none';
         }
-        data.keybinding.set(element.keybinding);
-        setVisibility(!!element.keybinding, data.keybinding.element);
         const actionTitle = this._keybindingService.lookupKeybinding(acceptSelectedActionCommand)?.getLabel();
         const previewTitle = this._keybindingService.lookupKeybinding(previewSelectedActionCommand)?.getLabel();
         data.container.classList.toggle('option-disabled', element.disabled);
@@ -106,10 +109,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localize(1686, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+                data.container.title = ( localize(1691, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localize(1687, "{0} to Apply", actionTitle));
+                data.container.title = ( localize(1692, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -136,7 +139,7 @@ function getKeyboardNavigationLabel(item) {
     return undefined;
 }
 let ActionList = class ActionList extends Disposable {
-    constructor(user, preview, items, _delegate, _contextViewService, _keybindingService, _layoutService) {
+    constructor(user, preview, items, _delegate, accessibilityProvider, _contextViewService, _keybindingService, _layoutService) {
         super();
         this._delegate = _delegate;
         this._contextViewService = _contextViewService;
@@ -163,15 +166,16 @@ let ActionList = class ActionList extends Disposable {
                     if (element.kind === ActionListItemKind.Action) {
                         let label = element.label ? stripNewlines(element?.label) : '';
                         if (element.disabled) {
-                            label = ( localize(1688, "{0}, Disabled Reason: {1}", label, element.disabled));
+                            label = ( localize(1693, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localize(1689, "Action Widget")),
+                getWidgetAriaLabel: () => ( localize(1694, "Action Widget")),
                 getRole: (e) => e.kind === ActionListItemKind.Action ? 'option' : 'separator',
                 getWidgetRole: () => 'listbox',
+                ...accessibilityProvider
             },
         })));
         this._list.style(defaultListStyles);
@@ -282,9 +286,9 @@ let ActionList = class ActionList extends Disposable {
     }
 };
 ActionList = ( __decorate([
-    ( __param(4, IContextViewService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, ILayoutService))
+    ( __param(5, IContextViewService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, ILayoutService))
 ], ActionList));
 function stripNewlines(str) {
     return str.replace(/\r\n|\r|\n/g, ' ');

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.d.ts

@@ -6,6 +6,7 @@ import { IContextKeyService } from "../../contextkey/common/contextkey.service.j
 import { IContextViewService } from "../../contextview/browser/contextView.service.js";
 import { IInstantiationService } from "../../instantiation/common/instantiation.js";
 import { StandardMouseEvent } from "../../../base/browser/mouseEvent.js";
+import { IListAccessibilityProvider } from "../../../base/browser/ui/list/listWidget.js";
 import { IActionWidgetService } from "./actionWidget.service.js";
 export declare class ActionWidgetService extends Disposable implements IActionWidgetService {
     private readonly _contextViewService;
@@ -15,7 +16,7 @@ export declare class ActionWidgetService extends Disposable implements IActionWi
     get isVisible(): boolean;
     private readonly _list;
     constructor(_contextViewService: IContextViewService, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService);
-    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[]): void;
+    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>): void;
     acceptSelected(preview?: boolean): void;
     focusPrevious(): void;
     focusNext(): void;

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

@@ -29,9 +29,9 @@ import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
 registerCss(actionWidget);
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1690, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1695, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1691, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1696, "Whether the action widget list is visible"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -44,9 +44,9 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         this._instantiationService = _instantiationService;
         this._list = this._register(( new MutableDisposable()));
     }
-    show(user, supportsPreview, items, delegate, anchor, container, actionBarActions) {
+    show(user, supportsPreview, items, delegate, anchor, container, actionBarActions, accessibilityProvider) {
         const visibleContext = ActionWidgetContextKeys.Visible.bindTo(this._contextKeyService);
-        const list = this._instantiationService.createInstance(ActionList, user, supportsPreview, items, delegate);
+        const list = this._instantiationService.createInstance(ActionList, user, supportsPreview, items, delegate, accessibilityProvider);
         this._contextViewService.showContextView({
             getAnchor: () => anchor,
             render: (container) => {
@@ -134,7 +134,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(1692, "Hide action widget")),
+            title: ( localize2(1697, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -151,7 +151,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(1693, "Select previous action")),
+            title: ( localize2(1698, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -172,7 +172,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(1694, "Select next action")),
+            title: ( localize2(1699, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -193,7 +193,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1695, "Accept selected action")),
+            title: ( localize2(1700, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -213,7 +213,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1696, "Preview selected action")),
+            title: ( localize2(1701, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.service.d.ts

@@ -1,11 +1,12 @@
 import { StandardMouseEvent } from "../../../base/browser/mouseEvent.js";
 import { IAnchor } from "../../../base/browser/ui/contextview/contextview.js";
+import { IListAccessibilityProvider } from "../../../base/browser/ui/list/listWidget.js";
 import { IAction } from "../../../base/common/actions.js";
 import { IActionListItem, IActionListDelegate } from "./actionList.js";
 export declare const IActionWidgetService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IActionWidgetService>;
 export interface IActionWidgetService {
     readonly _serviceBrand: undefined;
-    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[]): void;
+    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>): void;
     hide(didCancel?: boolean): void;
     readonly isVisible: boolean;
 }