@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/browser/parts/notifications/notificationsActions.js

@@ -0,0 +1,124 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/notificationsActions.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { CLEAR_NOTIFICATION, CLEAR_ALL_NOTIFICATIONS, TOGGLE_DO_NOT_DISTURB_MODE, HIDE_NOTIFICATIONS_CENTER, EXPAND_NOTIFICATION, COLLAPSE_NOTIFICATION } from './notificationsCommands.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+const clearIcon = ( registerIcon('notifications-clear', Codicon.close, ( localize('clearIcon', 'Icon for the clear action in notifications.'))));
+const clearAllIcon = ( registerIcon('notifications-clear-all', Codicon.clearAll, ( localize('clearAllIcon', 'Icon for the clear all action in notifications.'))));
+const hideIcon = ( registerIcon('notifications-hide', Codicon.chevronDown, ( localize('hideIcon', 'Icon for the hide action in notifications.'))));
+const expandIcon = ( registerIcon('notifications-expand', Codicon.chevronUp, ( localize('expandIcon', 'Icon for the expand action in notifications.'))));
+const collapseIcon = ( registerIcon('notifications-collapse', Codicon.chevronDown, ( localize('collapseIcon', 'Icon for the collapse action in notifications.'))));
+const configureIcon = ( registerIcon('notifications-configure', Codicon.gear, ( localize('configureIcon', 'Icon for the configure action in notifications.'))));
+const doNotDisturbIcon = ( registerIcon('notifications-do-not-disturb', Codicon.bellSlash, ( localize('doNotDisturbIcon', 'Icon for the mute all action in notifications.'))));
+let ClearNotificationAction = class ClearNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(clearIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(CLEAR_NOTIFICATION, notification);
+    }
+};
+ClearNotificationAction.ID = CLEAR_NOTIFICATION;
+ClearNotificationAction.LABEL = ( localize('clearNotification', "Clear Notification"));
+ClearNotificationAction = ( __decorate([
+    ( __param(2, ICommandService))
+], ClearNotificationAction));
+let ClearAllNotificationsAction = class ClearAllNotificationsAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(clearAllIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(CLEAR_ALL_NOTIFICATIONS);
+    }
+};
+ClearAllNotificationsAction.ID = CLEAR_ALL_NOTIFICATIONS;
+ClearAllNotificationsAction.LABEL = ( localize('clearNotifications', "Clear All Notifications"));
+ClearAllNotificationsAction = ( __decorate([
+    ( __param(2, ICommandService))
+], ClearAllNotificationsAction));
+let ToggleDoNotDisturbAction = class ToggleDoNotDisturbAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(doNotDisturbIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(TOGGLE_DO_NOT_DISTURB_MODE);
+    }
+};
+ToggleDoNotDisturbAction.ID = TOGGLE_DO_NOT_DISTURB_MODE;
+ToggleDoNotDisturbAction.LABEL = ( localize('toggleDoNotDisturbMode', "Toggle Do Not Disturb Mode"));
+ToggleDoNotDisturbAction = ( __decorate([
+    ( __param(2, ICommandService))
+], ToggleDoNotDisturbAction));
+let HideNotificationsCenterAction = class HideNotificationsCenterAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(hideIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(HIDE_NOTIFICATIONS_CENTER);
+    }
+};
+HideNotificationsCenterAction.ID = HIDE_NOTIFICATIONS_CENTER;
+HideNotificationsCenterAction.LABEL = ( localize('hideNotificationsCenter', "Hide Notifications"));
+HideNotificationsCenterAction = ( __decorate([
+    ( __param(2, ICommandService))
+], HideNotificationsCenterAction));
+let ExpandNotificationAction = class ExpandNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(expandIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(EXPAND_NOTIFICATION, notification);
+    }
+};
+ExpandNotificationAction.ID = EXPAND_NOTIFICATION;
+ExpandNotificationAction.LABEL = ( localize('expandNotification', "Expand Notification"));
+ExpandNotificationAction = ( __decorate([
+    ( __param(2, ICommandService))
+], ExpandNotificationAction));
+let CollapseNotificationAction = class CollapseNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(collapseIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(COLLAPSE_NOTIFICATION, notification);
+    }
+};
+CollapseNotificationAction.ID = COLLAPSE_NOTIFICATION;
+CollapseNotificationAction.LABEL = ( localize('collapseNotification', "Collapse Notification"));
+CollapseNotificationAction = ( __decorate([
+    ( __param(2, ICommandService))
+], CollapseNotificationAction));
+class ConfigureNotificationAction extends Action {
+    constructor(id, label, configurationActions) {
+        super(id, label, ThemeIcon.asClassName(configureIcon));
+        this.configurationActions = configurationActions;
+    }
+}
+ConfigureNotificationAction.ID = 'workbench.action.configureNotification';
+ConfigureNotificationAction.LABEL = ( localize('configureNotification', "Configure Notification"));
+let CopyNotificationMessageAction = class CopyNotificationMessageAction extends Action {
+    constructor(id, label, clipboardService) {
+        super(id, label);
+        this.clipboardService = clipboardService;
+    }
+    run(notification) {
+        return this.clipboardService.writeText(notification.message.raw);
+    }
+};
+CopyNotificationMessageAction.ID = 'workbench.action.copyNotificationMessage';
+CopyNotificationMessageAction.LABEL = ( localize('copyNotification', "Copy Text"));
+CopyNotificationMessageAction = ( __decorate([
+    ( __param(2, IClipboardService))
+], CopyNotificationMessageAction));
+export { ClearAllNotificationsAction, ClearNotificationAction, CollapseNotificationAction, ConfigureNotificationAction, CopyNotificationMessageAction, ExpandNotificationAction, HideNotificationsCenterAction, ToggleDoNotDisturbAction };

package/dist/vscode/vs/workbench/browser/parts/notifications/notificationsAlerts.js

@@ -0,0 +1,58 @@
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Severity, NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+class NotificationsAlerts extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        for (const notification of model.notifications) {
+            this.triggerAriaAlert(notification);
+        }
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.model.onDidChangeNotification(e => this.onDidChangeNotification(e)));
+    }
+    onDidChangeNotification(e) {
+        if (e.kind === 0 ) {
+            this.triggerAriaAlert(e.item);
+            if (e.item.severity === Severity.Error) {
+                if (e.item.message.original instanceof Error) {
+                    console.error(e.item.message.original);
+                }
+                else {
+                    console.error(toErrorMessage(( e.item.message.linkedText.toString()), true));
+                }
+            }
+        }
+    }
+    triggerAriaAlert(notification) {
+        if (notification.priority === NotificationPriority.SILENT) {
+            return;
+        }
+        const listener = notification.onDidChangeContent(e => {
+            if (e.kind === 1 ) {
+                this.doTriggerAriaAlert(notification);
+            }
+        });
+        Event.once(notification.onDidClose)(() => listener.dispose());
+        this.doTriggerAriaAlert(notification);
+    }
+    doTriggerAriaAlert(notification) {
+        let alertText;
+        if (notification.severity === Severity.Error) {
+            alertText = ( localize('alertErrorMessage', "Error: {0}", ( notification.message.linkedText.toString())));
+        }
+        else if (notification.severity === Severity.Warning) {
+            alertText = ( localize('alertWarningMessage', "Warning: {0}", ( notification.message.linkedText.toString())));
+        }
+        else {
+            alertText = ( localize('alertInfoMessage', "Info: {0}", ( notification.message.linkedText.toString())));
+        }
+        alert(alertText);
+    }
+}
+export { NotificationsAlerts };

package/dist/vscode/vs/workbench/browser/parts/notifications/notificationsCenter.js

@@ -0,0 +1,224 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/notificationsCenter.css";
+import "../../../../../../assets/notificationsActions.css";
+import { NOTIFICATIONS_CENTER_BORDER, NOTIFICATIONS_CENTER_HEADER_FOREGROUND, NOTIFICATIONS_CENTER_HEADER_BACKGROUND } from '../../../common/theme.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { NotificationActionRunner } from './notificationsCommands.js';
+import { NotificationsList } from './notificationsList.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Dimension, isAncestor } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { widgetShadow } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ClearAllNotificationsAction, ToggleDoNotDisturbAction, HideNotificationsCenterAction } from './notificationsActions.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { assertIsDefined, assertAllDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { NotificationsCenterVisibleContext } from '../../../common/contextkeys.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+let NotificationsCenter = class NotificationsCenter extends Themable {
+    constructor(container, model, themeService, instantiationService, layoutService, contextKeyService, editorGroupService, keybindingService, notificationService) {
+        super(themeService);
+        this.container = container;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.contextKeyService = contextKeyService;
+        this.editorGroupService = editorGroupService;
+        this.keybindingService = keybindingService;
+        this.notificationService = notificationService;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.notificationsCenterVisibleContextKey = NotificationsCenterVisibleContext.bindTo(this.contextKeyService);
+        this.notificationsCenterVisibleContextKey = NotificationsCenterVisibleContext.bindTo(contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.model.onDidChangeNotification(e => this.onDidChangeNotification(e)));
+        this._register(this.layoutService.onDidLayout(dimension => this.layout(Dimension.lift(dimension))));
+        this._register(this.notificationService.onDidChangeDoNotDisturbMode(() => this.onDidChangeDoNotDisturbMode()));
+    }
+    onDidChangeDoNotDisturbMode() {
+        this.hide();
+    }
+    get isVisible() {
+        return !!this._isVisible;
+    }
+    show() {
+        if (this._isVisible) {
+            const notificationsList = assertIsDefined(this.notificationsList);
+            notificationsList.show(true );
+            return;
+        }
+        if (!this.notificationsCenterContainer) {
+            this.create();
+        }
+        this.updateTitle();
+        const [notificationsList, notificationsCenterContainer] = assertAllDefined(this.notificationsList, this.notificationsCenterContainer);
+        this._isVisible = true;
+        notificationsCenterContainer.classList.add('visible');
+        notificationsList.show();
+        this.layout(this.workbenchDimensions);
+        notificationsList.updateNotificationsList(0, 0, this.model.notifications);
+        notificationsList.focusFirst();
+        this.updateStyles();
+        this.model.notifications.forEach(notification => notification.updateVisibility(true));
+        this.notificationsCenterVisibleContextKey.set(true);
+        this._onDidChangeVisibility.fire();
+    }
+    updateTitle() {
+        const [notificationsCenterTitle, clearAllAction] = assertAllDefined(this.notificationsCenterTitle, this.clearAllAction);
+        if (this.model.notifications.length === 0) {
+            notificationsCenterTitle.textContent = ( localize('notificationsEmpty', "No new notifications"));
+            clearAllAction.enabled = false;
+        }
+        else {
+            notificationsCenterTitle.textContent = ( localize('notifications', "Notifications"));
+            clearAllAction.enabled = ( this.model.notifications.some(notification => !notification.hasProgress));
+        }
+    }
+    create() {
+        this.notificationsCenterContainer = document.createElement('div');
+        this.notificationsCenterContainer.classList.add('notifications-center');
+        this.notificationsCenterHeader = document.createElement('div');
+        this.notificationsCenterHeader.classList.add('notifications-center-header');
+        this.notificationsCenterContainer.appendChild(this.notificationsCenterHeader);
+        this.notificationsCenterTitle = document.createElement('span');
+        this.notificationsCenterTitle.classList.add('notifications-center-header-title');
+        this.notificationsCenterHeader.appendChild(this.notificationsCenterTitle);
+        const toolbarContainer = document.createElement('div');
+        toolbarContainer.classList.add('notifications-center-header-toolbar');
+        this.notificationsCenterHeader.appendChild(toolbarContainer);
+        const actionRunner = this._register(this.instantiationService.createInstance(NotificationActionRunner));
+        const notificationsToolBar = this._register(( new ActionBar(toolbarContainer, {
+            ariaLabel: ( localize('notificationsToolbar', "Notification Center Actions")),
+            actionRunner
+        })));
+        this.clearAllAction = this._register(this.instantiationService.createInstance(ClearAllNotificationsAction, ClearAllNotificationsAction.ID, ClearAllNotificationsAction.LABEL));
+        notificationsToolBar.push(this.clearAllAction, { icon: true, label: false, keybinding: this.getKeybindingLabel(this.clearAllAction) });
+        this.toggleDoNotDisturbAction = this._register(this.instantiationService.createInstance(ToggleDoNotDisturbAction, ToggleDoNotDisturbAction.ID, ToggleDoNotDisturbAction.LABEL));
+        notificationsToolBar.push(this.toggleDoNotDisturbAction, { icon: true, label: false, keybinding: this.getKeybindingLabel(this.toggleDoNotDisturbAction) });
+        const hideAllAction = this._register(this.instantiationService.createInstance(HideNotificationsCenterAction, HideNotificationsCenterAction.ID, HideNotificationsCenterAction.LABEL));
+        notificationsToolBar.push(hideAllAction, { icon: true, label: false, keybinding: this.getKeybindingLabel(hideAllAction) });
+        this.notificationsList = this.instantiationService.createInstance(NotificationsList, this.notificationsCenterContainer, {
+            widgetAriaLabel: ( localize('notificationsCenterWidgetAriaLabel', "Notifications Center"))
+        });
+        this.container.appendChild(this.notificationsCenterContainer);
+    }
+    getKeybindingLabel(action) {
+        const keybinding = this.keybindingService.lookupKeybinding(action.id);
+        return keybinding ? keybinding.getLabel() : null;
+    }
+    onDidChangeNotification(e) {
+        if (!this._isVisible) {
+            return;
+        }
+        let focusEditor = false;
+        const [notificationsList, notificationsCenterContainer] = assertAllDefined(this.notificationsList, this.notificationsCenterContainer);
+        switch (e.kind) {
+            case 0 :
+                notificationsList.updateNotificationsList(e.index, 0, [e.item]);
+                e.item.updateVisibility(true);
+                break;
+            case 1 :
+                switch (e.detail) {
+                    case 2 :
+                        notificationsList.updateNotificationsList(e.index, 1, [e.item]);
+                        break;
+                    case 1 :
+                        if (e.item.expanded) {
+                            notificationsList.updateNotificationHeight(e.item);
+                        }
+                        break;
+                }
+                break;
+            case 2 :
+                notificationsList.updateNotificationsList(e.index, 1, [e.item]);
+                break;
+            case 3 :
+                focusEditor = isAncestor(document.activeElement, notificationsCenterContainer);
+                notificationsList.updateNotificationsList(e.index, 1);
+                e.item.updateVisibility(false);
+                break;
+        }
+        this.updateTitle();
+        if (this.model.notifications.length === 0) {
+            this.hide();
+            if (focusEditor) {
+                this.editorGroupService.activeGroup.focus();
+            }
+        }
+    }
+    hide() {
+        if (!this._isVisible || !this.notificationsCenterContainer || !this.notificationsList) {
+            return;
+        }
+        const focusEditor = isAncestor(document.activeElement, this.notificationsCenterContainer);
+        this._isVisible = false;
+        this.notificationsCenterContainer.classList.remove('visible');
+        this.notificationsList.hide();
+        this.model.notifications.forEach(notification => notification.updateVisibility(false));
+        this.notificationsCenterVisibleContextKey.set(false);
+        this._onDidChangeVisibility.fire();
+        if (focusEditor) {
+            this.editorGroupService.activeGroup.focus();
+        }
+    }
+    updateStyles() {
+        if (this.notificationsCenterContainer && this.notificationsCenterHeader) {
+            const widgetShadowColor = this.getColor(widgetShadow);
+            this.notificationsCenterContainer.style.boxShadow = widgetShadowColor ? `0 0 8px 2px ${widgetShadowColor}` : '';
+            const borderColor = this.getColor(NOTIFICATIONS_CENTER_BORDER);
+            this.notificationsCenterContainer.style.border = borderColor ? `1px solid ${borderColor}` : '';
+            const headerForeground = this.getColor(NOTIFICATIONS_CENTER_HEADER_FOREGROUND);
+            this.notificationsCenterHeader.style.color = headerForeground ?? '';
+            const headerBackground = this.getColor(NOTIFICATIONS_CENTER_HEADER_BACKGROUND);
+            this.notificationsCenterHeader.style.background = headerBackground ?? '';
+        }
+    }
+    layout(dimension) {
+        this.workbenchDimensions = dimension;
+        if (this._isVisible && this.notificationsCenterContainer) {
+            const maxWidth = NotificationsCenter.MAX_DIMENSIONS.width;
+            const maxHeight = NotificationsCenter.MAX_DIMENSIONS.height;
+            let availableWidth = maxWidth;
+            let availableHeight = maxHeight;
+            if (this.workbenchDimensions) {
+                availableWidth = this.workbenchDimensions.width;
+                availableWidth -= (2 * 8);
+                availableHeight = this.workbenchDimensions.height - 35 ;
+                if (this.layoutService.isVisible("workbench.parts.statusbar" )) {
+                    availableHeight -= 22;
+                }
+                if (this.layoutService.isVisible("workbench.parts.titlebar" )) {
+                    availableHeight -= 22;
+                }
+                availableHeight -= (2 * 12);
+            }
+            const notificationsList = assertIsDefined(this.notificationsList);
+            notificationsList.layout(Math.min(maxWidth, availableWidth), Math.min(maxHeight, availableHeight));
+        }
+    }
+    clearAll() {
+        this.hide();
+        for (const notification of [...this.model.notifications] ) {
+            if (!notification.hasProgress) {
+                notification.close();
+            }
+        }
+    }
+};
+NotificationsCenter.MAX_DIMENSIONS = ( new Dimension(450, 400));
+NotificationsCenter = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IEditorGroupsService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, INotificationService))
+], NotificationsCenter));
+export { NotificationsCenter };

package/dist/vscode/vs/workbench/browser/parts/notifications/notificationsCommands.js

@@ -0,0 +1,241 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { isNotificationViewItem } from '../../../common/notifications.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IListService, WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { notificationToMetrics } from './notificationsTelemetry.js';
+import { NotificationsCenterVisibleContext, NotificationFocusedContext, NotificationsToastsVisibleContext } from '../../../common/contextkeys.js';
+import { INotificationService, NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+const SHOW_NOTIFICATIONS_CENTER = 'notifications.showList';
+const HIDE_NOTIFICATIONS_CENTER = 'notifications.hideList';
+const TOGGLE_NOTIFICATIONS_CENTER = 'notifications.toggleList';
+const HIDE_NOTIFICATION_TOAST = 'notifications.hideToasts';
+const FOCUS_NOTIFICATION_TOAST = 'notifications.focusToasts';
+const FOCUS_NEXT_NOTIFICATION_TOAST = 'notifications.focusNextToast';
+const FOCUS_PREVIOUS_NOTIFICATION_TOAST = 'notifications.focusPreviousToast';
+const FOCUS_FIRST_NOTIFICATION_TOAST = 'notifications.focusFirstToast';
+const FOCUS_LAST_NOTIFICATION_TOAST = 'notifications.focusLastToast';
+const COLLAPSE_NOTIFICATION = 'notification.collapse';
+const EXPAND_NOTIFICATION = 'notification.expand';
+const ACCEPT_PRIMARY_ACTION_NOTIFICATION = 'notification.acceptPrimaryAction';
+const TOGGLE_NOTIFICATION = 'notification.toggle';
+const CLEAR_NOTIFICATION = 'notification.clear';
+const CLEAR_ALL_NOTIFICATIONS = 'notifications.clearAll';
+const TOGGLE_DO_NOT_DISTURB_MODE = 'notifications.toggleDoNotDisturbMode';
+function registerNotificationCommands(center, toasts, model) {
+    function getNotificationFromContext(listService, context) {
+        if (isNotificationViewItem(context)) {
+            return context;
+        }
+        const list = listService.lastFocusedList;
+        if (list instanceof WorkbenchList) {
+            const focusedElement = list.getFocusedElements()[0];
+            if (isNotificationViewItem(focusedElement)) {
+                return focusedElement;
+            }
+        }
+        return undefined;
+    }
+    CommandsRegistry.registerCommand(SHOW_NOTIFICATIONS_CENTER, () => {
+        toasts.hide();
+        center.show();
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: HIDE_NOTIFICATIONS_CENTER,
+        weight: 200  + 50,
+        when: NotificationsCenterVisibleContext,
+        primary: 9 ,
+        handler: accessor => {
+            const telemetryService = accessor.get(ITelemetryService);
+            for (const notification of model.notifications) {
+                if (notification.visible) {
+                    telemetryService.publicLog2('notification:hide', notificationToMetrics(notification.message.original, notification.sourceId, notification.priority === NotificationPriority.SILENT));
+                }
+            }
+            center.hide();
+        }
+    });
+    CommandsRegistry.registerCommand(TOGGLE_NOTIFICATIONS_CENTER, accessor => {
+        if (center.isVisible) {
+            center.hide();
+        }
+        else {
+            toasts.hide();
+            center.show();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: CLEAR_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 20 ,
+        mac: {
+            primary: 2048  | 1
+        },
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            if (notification && !notification.hasProgress) {
+                notification.close();
+            }
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: EXPAND_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 17 ,
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            notification?.expand();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: ACCEPT_PRIMARY_ACTION_NOTIFICATION,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(NotificationsToastsVisibleContext)),
+        primary: 2048  | 1024  | 31 ,
+        handler: (accessor) => {
+            const actionRunner = accessor.get(IInstantiationService).createInstance(NotificationActionRunner);
+            const notification = firstOrDefault(model.notifications);
+            if (!notification) {
+                return;
+            }
+            const primaryAction = notification.actions?.primary ? firstOrDefault(notification.actions.primary) : undefined;
+            if (!primaryAction) {
+                return;
+            }
+            actionRunner.run(primaryAction, notification);
+            notification.close();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: COLLAPSE_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 15 ,
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            notification?.collapse();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: TOGGLE_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 10 ,
+        secondary: [3 ],
+        handler: accessor => {
+            const notification = getNotificationFromContext(accessor.get(IListService));
+            notification?.toggle();
+        }
+    });
+    CommandsRegistry.registerCommand(HIDE_NOTIFICATION_TOAST, accessor => {
+        const telemetryService = accessor.get(ITelemetryService);
+        for (const notification of model.notifications) {
+            if (notification.visible) {
+                telemetryService.publicLog2('notification:hide', notificationToMetrics(notification.message.original, notification.sourceId, notification.priority === NotificationPriority.SILENT));
+            }
+        }
+        toasts.hide();
+    });
+    KeybindingsRegistry.registerKeybindingRule({
+        id: HIDE_NOTIFICATION_TOAST,
+        weight: 200  - 50,
+        when: NotificationsToastsVisibleContext,
+        primary: 9
+    });
+    KeybindingsRegistry.registerKeybindingRule({
+        id: HIDE_NOTIFICATION_TOAST,
+        weight: 200  + 100,
+        when: ( ContextKeyExpr.and(NotificationsToastsVisibleContext, NotificationFocusedContext)),
+        primary: 9
+    });
+    CommandsRegistry.registerCommand(FOCUS_NOTIFICATION_TOAST, () => toasts.focus());
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_NEXT_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext)),
+        primary: 18 ,
+        handler: () => {
+            toasts.focusNext();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_PREVIOUS_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext)),
+        primary: 16 ,
+        handler: () => {
+            toasts.focusPrevious();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_FIRST_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext)),
+        primary: 11 ,
+        secondary: [14 ],
+        handler: () => {
+            toasts.focusFirst();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_LAST_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext)),
+        primary: 12 ,
+        secondary: [13 ],
+        handler: () => {
+            toasts.focusLast();
+        }
+    });
+    CommandsRegistry.registerCommand(CLEAR_ALL_NOTIFICATIONS, () => center.clearAll());
+    CommandsRegistry.registerCommand(TOGGLE_DO_NOT_DISTURB_MODE, accessor => {
+        const notificationService = accessor.get(INotificationService);
+        notificationService.doNotDisturbMode = !notificationService.doNotDisturbMode;
+    });
+    const category = { value: ( localize('notifications', "Notifications")), original: 'Notifications' };
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: SHOW_NOTIFICATIONS_CENTER, title: { value: ( localize('showNotifications', "Show Notifications")), original: 'Show Notifications' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: HIDE_NOTIFICATIONS_CENTER, title: { value: ( localize('hideNotifications', "Hide Notifications")), original: 'Hide Notifications' }, category }, when: NotificationsCenterVisibleContext });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: CLEAR_ALL_NOTIFICATIONS, title: { value: ( localize('clearAllNotifications', "Clear All Notifications")), original: 'Clear All Notifications' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: ACCEPT_PRIMARY_ACTION_NOTIFICATION, title: { value: ( localize('acceptNotificationPrimaryAction', "Accept Notification Primary Action")), original: 'Accept Notification Primary Action' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: TOGGLE_DO_NOT_DISTURB_MODE, title: { value: ( localize('toggleDoNotDisturbMode', "Toggle Do Not Disturb Mode")), original: 'Toggle Do Not Disturb Mode' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: FOCUS_NOTIFICATION_TOAST, title: { value: ( localize('focusNotificationToasts', "Focus Notification Toast")), original: 'Focus Notification Toast' }, category }, when: NotificationsToastsVisibleContext });
+}
+let NotificationActionRunner = class NotificationActionRunner extends ActionRunner {
+    constructor(telemetryService, notificationService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+    }
+    async runAction(action, context) {
+        this.telemetryService.publicLog2('workbenchActionExecuted', { id: action.id, from: 'message' });
+        if (isNotificationViewItem(context)) {
+            this.telemetryService.publicLog2('notification:actionExecuted', {
+                id: ( hash(( context.message.original.toString())).toString()),
+                actionLabel: action.label,
+                source: context.sourceId || 'core',
+                silent: context.priority === NotificationPriority.SILENT
+            });
+        }
+        try {
+            await super.runAction(action, context);
+        }
+        catch (error) {
+            this.notificationService.error(error);
+        }
+    }
+};
+NotificationActionRunner = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, INotificationService))
+], NotificationActionRunner));
+export { ACCEPT_PRIMARY_ACTION_NOTIFICATION, CLEAR_ALL_NOTIFICATIONS, CLEAR_NOTIFICATION, COLLAPSE_NOTIFICATION, EXPAND_NOTIFICATION, HIDE_NOTIFICATIONS_CENTER, HIDE_NOTIFICATION_TOAST, NotificationActionRunner, SHOW_NOTIFICATIONS_CENTER, TOGGLE_DO_NOT_DISTURB_MODE, registerNotificationCommands };