@codingame/monaco-vscode-api 15.0.0 → 15.0.2

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

@@ -262,169 +262,169 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1588, 'Error at Position')),
+        name: ( localize(1591, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1589, 'Error')),
+        announcementMessage: ( localize(1592, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1590, 'Warning at Position')),
+        name: ( localize(1593, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1591, 'Warning')),
+        announcementMessage: ( localize(1594, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1592, 'Error on Line')),
+        name: ( localize(1595, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1593, 'Error on Line')),
+        announcementMessage: ( localize(1596, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1594, 'Warning on Line')),
+        name: ( localize(1597, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1595, 'Warning on Line')),
+        announcementMessage: ( localize(1598, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1596, 'Folded Area on Line')),
+        name: ( localize(1599, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1597, 'Folded')),
+        announcementMessage: ( localize(1600, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1598, 'Breakpoint on Line')),
+        name: ( localize(1601, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1599, 'Breakpoint')),
+        announcementMessage: ( localize(1602, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1600, 'Inline Suggestion on Line')),
+        name: ( localize(1603, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1601, 'Terminal Quick Fix')),
+        name: ( localize(1604, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1602, 'Quick Fix')),
+        announcementMessage: ( localize(1605, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1603, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1606, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1604, 'Breakpoint')),
+        announcementMessage: ( localize(1607, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1605, 'No Inlay Hints on Line')),
+        name: ( localize(1608, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1606, 'No Inlay Hints')),
+        announcementMessage: ( localize(1609, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1607, 'Task Completed')),
+        name: ( localize(1610, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1608, 'Task Completed')),
+        announcementMessage: ( localize(1611, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1609, 'Task Failed')),
+        name: ( localize(1612, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1610, 'Task Failed')),
+        announcementMessage: ( localize(1613, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1611, 'Terminal Command Failed')),
+        name: ( localize(1614, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1612, 'Command Failed')),
+        announcementMessage: ( localize(1615, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1613, 'Terminal Command Succeeded')),
+        name: ( localize(1616, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(1614, 'Command Succeeded')),
+        announcementMessage: ( localize(1617, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1615, 'Terminal Bell')),
+        name: ( localize(1618, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1616, 'Terminal Bell')),
+        announcementMessage: ( localize(1619, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1617, 'Notebook Cell Completed')),
+        name: ( localize(1620, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1618, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1621, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1619, 'Notebook Cell Failed')),
+        name: ( localize(1622, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1620, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1623, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1621, 'Diff Line Inserted')),
+        name: ( localize(1624, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1622, 'Diff Line Deleted')),
+        name: ( localize(1625, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1623, 'Diff Line Modified')),
+        name: ( localize(1626, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1624, 'Chat Edit Modified File')),
+        name: ( localize(1627, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1625, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1628, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1626, 'Chat Request Sent')),
+        name: ( localize(1629, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1627, 'Chat Request Sent')),
+        announcementMessage: ( localize(1630, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1628, 'Chat Response Received')),
+        name: ( localize(1631, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -437,59 +437,59 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1629, 'Code Action Request Triggered')),
+        name: ( localize(1632, 'Code Action Request Triggered')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1630, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1633, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1631, 'Code Action Applied')),
+        name: ( localize(1634, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.voiceRecordingStopped,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1632, 'Progress')),
+        name: ( localize(1635, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1633, 'Progress')),
+        announcementMessage: ( localize(1636, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1634, 'Clear')),
+        name: ( localize(1637, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1635, 'Clear')),
+        announcementMessage: ( localize(1638, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1636, 'Save')),
+        name: ( localize(1639, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1637, 'Save')),
+        announcementMessage: ( localize(1640, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1638, 'Format')),
+        name: ( localize(1641, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1639, 'Format')),
+        announcementMessage: ( localize(1642, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1640, 'Voice Recording Started')),
+        name: ( localize(1643, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1641, 'Voice Recording Stopped')),
+        name: ( localize(1644, '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(1642, 'View')),
-    Help: ( localize2(1643, 'Help')),
-    Test: ( localize2(1644, 'Test')),
-    File: ( localize2(1645, 'File')),
-    Preferences: ( localize2(1646, 'Preferences')),
-    Developer: ( localize2(1647, "Developer")),
+    View: ( localize2(1645, 'View')),
+    Help: ( localize2(1646, 'Help')),
+    Test: ( localize2(1647, 'Test')),
+    File: ( localize2(1648, 'File')),
+    Preferences: ( localize2(1649, 'Preferences')),
+    Developer: ( localize2(1650, "Developer")),
 }));
 
 export { Categories };

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

@@ -1,17 +1,19 @@
 
-import '../../../base/browser/dom.js';
-import '../../../base/common/lifecycle.js';
-import '../../../base/common/platform.js';
-import '../../../nls.js';
-import '../../../base/browser/ui/keybindingLabel/keybindingLabel.css.js';
-import '../../../base/browser/ui/list/listWidget.js';
-import '../../../base/common/cancellation.js';
-import '../../../base/common/codicons.js';
-import '../../../base/common/themables.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { setVisibility } from '../../../base/browser/dom.js';
+import { KeybindingLabel } from '../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { List } from '../../../base/browser/ui/list/listWidget.js';
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { OS } from '../../../base/common/platform.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
 import './actionWidget.css.js';
-import '../../instantiation/common/instantiation.js';
-import '../../theme/browser/defaultStyles.js';
-import '../../theme/common/colorUtils.js';
+import { localize } from '../../../nls.js';
+import { IContextViewService } from '../../contextview/browser/contextView.service.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { defaultListStyles } from '../../theme/browser/defaultStyles.js';
+import { asCssVariable } from '../../theme/common/colorUtils.js';
 import '../../theme/common/colors/baseColors.js';
 import '../../theme/common/colors/chartsColors.js';
 import '../../theme/common/colors/editorColors.js';
@@ -23,10 +25,250 @@ import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 
+const acceptSelectedActionCommand = 'acceptSelectedCodeAction';
+const previewSelectedActionCommand = 'previewSelectedCodeAction';
 var ActionListItemKind;
 (function (ActionListItemKind) {
     ActionListItemKind["Action"] = "action";
     ActionListItemKind["Header"] = "header";
 })(ActionListItemKind || (ActionListItemKind = {}));
+class HeaderRenderer {
+    get templateId() { return ActionListItemKind.Header; }
+    renderTemplate(container) {
+        container.classList.add('group-header');
+        const text = document.createElement('span');
+        container.append(text);
+        return { container, text };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.text.textContent = element.group?.title ?? '';
+    }
+    disposeTemplate(_templateData) {
+    }
+}
+let ActionItemRenderer = class ActionItemRenderer {
+    get templateId() { return ActionListItemKind.Action; }
+    constructor(_supportsPreview, _keybindingService) {
+        this._supportsPreview = _supportsPreview;
+        this._keybindingService = _keybindingService;
+    }
+    renderTemplate(container) {
+        container.classList.add(this.templateId);
+        const icon = document.createElement('div');
+        icon.className = 'icon';
+        container.append(icon);
+        const text = document.createElement('span');
+        text.className = 'title';
+        container.append(text);
+        const keybinding = ( new KeybindingLabel(container, OS));
+        return { container, icon, text, keybinding };
+    }
+    renderElement(element, _index, data) {
+        if (element.group?.icon) {
+            data.icon.className = ThemeIcon.asClassName(element.group.icon);
+            if (element.group.icon.color) {
+                data.icon.style.color = asCssVariable(element.group.icon.color.id);
+            }
+        }
+        else {
+            data.icon.className = ThemeIcon.asClassName(Codicon.lightBulb);
+            data.icon.style.color = 'var(--vscode-editorLightBulb-foreground)';
+        }
+        if (!element.item || !element.label) {
+            return;
+        }
+        setVisibility(!element.hideIcon, data.icon);
+        data.text.textContent = stripNewlines(element.label);
+        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);
+        if (element.disabled) {
+            data.container.title = element.label;
+        }
+        else if (actionTitle && previewTitle) {
+            if (this._supportsPreview && element.canPreview) {
+                data.container.title = ( localize(1651, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+            }
+            else {
+                data.container.title = ( localize(1652, "{0} to Apply", actionTitle));
+            }
+        }
+        else {
+            data.container.title = '';
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.keybinding.dispose();
+    }
+};
+ActionItemRenderer = ( __decorate([
+    ( __param(1, IKeybindingService))
+], ActionItemRenderer));
+class AcceptSelectedEvent extends UIEvent {
+    constructor() { super('acceptSelectedAction'); }
+}
+class PreviewSelectedEvent extends UIEvent {
+    constructor() { super('previewSelectedAction'); }
+}
+function getKeyboardNavigationLabel(item) {
+    if (item.kind === 'action') {
+        return item.label;
+    }
+    return undefined;
+}
+let ActionList = class ActionList extends Disposable {
+    constructor(user, preview, items, _delegate, _contextViewService, _keybindingService) {
+        super();
+        this._delegate = _delegate;
+        this._contextViewService = _contextViewService;
+        this._keybindingService = _keybindingService;
+        this._actionLineHeight = 24;
+        this._headerLineHeight = 26;
+        this.cts = this._register(( new CancellationTokenSource()));
+        this.domNode = document.createElement('div');
+        this.domNode.classList.add('actionList');
+        const virtualDelegate = {
+            getHeight: element => element.kind === ActionListItemKind.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()),
+        ], {
+            keyboardSupport: false,
+            typeNavigationEnabled: true,
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel },
+            accessibilityProvider: {
+                getAriaLabel: element => {
+                    if (element.kind === ActionListItemKind.Action) {
+                        let label = element.label ? stripNewlines(element?.label) : '';
+                        if (element.disabled) {
+                            label = ( localize(1653, "{0}, Disabled Reason: {1}", label, element.disabled));
+                        }
+                        return label;
+                    }
+                    return null;
+                },
+                getWidgetAriaLabel: () => ( localize(1654, "Action Widget")),
+                getRole: (e) => e.kind === ActionListItemKind.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)));
+        this._register(this._list.onDidChangeFocus(() => this.onFocus()));
+        this._register(this._list.onDidChangeSelection(e => this.onListSelection(e)));
+        this._allMenuItems = items;
+        this._list.splice(0, this._list.length, this._allMenuItems);
+        if (this._list.length) {
+            this.focusNext();
+        }
+    }
+    focusCondition(element) {
+        return !element.disabled && element.kind === ActionListItemKind.Action;
+    }
+    hide(didCancel) {
+        this._delegate.onHide(didCancel);
+        this.cts.cancel();
+        this._contextViewService.hideContextView();
+    }
+    layout(minWidth) {
+        const numHeaders = this._allMenuItems.filter(item => item.kind === 'header').length;
+        const itemsHeight = this._allMenuItems.length * this._actionLineHeight;
+        const heightWithHeaders = itemsHeight + numHeaders * this._headerLineHeight - numHeaders * this._actionLineHeight;
+        this._list.layout(heightWithHeaders);
+        let maxWidth = minWidth;
+        if (this._allMenuItems.length >= 50) {
+            maxWidth = 380;
+        }
+        else {
+            const itemWidths = ( this._allMenuItems.map((_, index) => {
+                const element = this.domNode.ownerDocument.getElementById(this._list.getElementID(index));
+                if (element) {
+                    element.style.width = 'auto';
+                    const width = element.getBoundingClientRect().width;
+                    element.style.width = '';
+                    return width;
+                }
+                return 0;
+            }));
+            maxWidth = Math.max(...itemWidths, minWidth);
+        }
+        const maxVhPrecentage = 0.7;
+        const height = Math.min(heightWithHeaders, this.domNode.ownerDocument.body.clientHeight * maxVhPrecentage);
+        this._list.layout(height, maxWidth);
+        this.domNode.style.height = `${height}px`;
+        this._list.domFocus();
+        return maxWidth;
+    }
+    focusPrevious() {
+        this._list.focusPrevious(1, true, undefined, this.focusCondition);
+    }
+    focusNext() {
+        this._list.focusNext(1, true, undefined, this.focusCondition);
+    }
+    acceptSelected(preview) {
+        const focused = this._list.getFocus();
+        if (focused.length === 0) {
+            return;
+        }
+        const focusIndex = focused[0];
+        const element = this._list.element(focusIndex);
+        if (!this.focusCondition(element)) {
+            return;
+        }
+        const event = preview ? ( new PreviewSelectedEvent()) : ( new AcceptSelectedEvent());
+        this._list.setSelection([focusIndex], event);
+    }
+    onListSelection(e) {
+        if (!e.elements.length) {
+            return;
+        }
+        const element = e.elements[0];
+        if (element.item && this.focusCondition(element)) {
+            this._delegate.onSelect(element.item, e.browserEvent instanceof PreviewSelectedEvent);
+        }
+        else {
+            this._list.setSelection([]);
+        }
+    }
+    onFocus() {
+        const focused = this._list.getFocus();
+        if (focused.length === 0) {
+            return;
+        }
+        const focusIndex = focused[0];
+        const element = this._list.element(focusIndex);
+        this._delegate.onFocus?.(element.item);
+    }
+    async onListHover(e) {
+        const element = e.element;
+        if (element && element.item && this.focusCondition(element)) {
+            if (this._delegate.onHover && !element.disabled && element.kind === ActionListItemKind.Action) {
+                const result = await this._delegate.onHover(element.item, this.cts.token);
+                element.canPreview = result ? result.canPreview : undefined;
+            }
+            if (e.index) {
+                this._list.splice(e.index, 1, [element]);
+            }
+        }
+        this._list.setFocus(typeof e.index === 'number' ? [e.index] : []);
+    }
+    onListClick(e) {
+        if (e.element && this.focusCondition(e.element)) {
+            this._list.setFocus([]);
+        }
+    }
+};
+ActionList = ( __decorate([
+    ( __param(4, IContextViewService)),
+    ( __param(5, IKeybindingService))
+], ActionList));
+function stripNewlines(str) {
+    return str.replace(/\r\n|\r|\n/g, ' ');
+}
 
-export { ActionListItemKind };
+export { ActionList, ActionListItemKind, acceptSelectedActionCommand, previewSelectedActionCommand };

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

@@ -0,0 +1,26 @@
+import { IAnchor } from "../../../base/browser/ui/contextview/contextview.js";
+import { IAction } from "../../../base/common/actions.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IActionListDelegate, IActionListItem } from "./actionList.js";
+import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
+import { IContextViewService } from "../../contextview/browser/contextView.service.js";
+import { IInstantiationService } from "../../instantiation/common/instantiation.js";
+import { IActionWidgetService } from "./actionWidget.service.js";
+export declare class ActionWidgetService extends Disposable implements IActionWidgetService {
+    private readonly _contextViewService;
+    private readonly _contextKeyService;
+    private readonly _instantiationService;
+    readonly _serviceBrand: undefined;
+    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: IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[]): void;
+    acceptSelected(preview?: boolean): void;
+    focusPrevious(): void;
+    focusNext(): void;
+    hide(didCancel?: boolean): void;
+    clear(): void;
+    private _renderWidget;
+    private _createActionBar;
+    private _onWidgetClosed;
+}