@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

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

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

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

@@ -0,0 +1,73 @@
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
+import { Severity, NotificationPriority } from '../../../../platform/notification/common/notification.js';
+import { Event } from '../../../../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 = ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsAlerts',
+                'alertErrorMessage',
+                "Error: {0}",
+                ( notification.message.linkedText.toString())
+            ));
+        }
+        else if (notification.severity === Severity.Warning) {
+            alertText = ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsAlerts',
+                'alertWarningMessage',
+                "Warning: {0}",
+                ( notification.message.linkedText.toString())
+            ));
+        }
+        else {
+            alertText = ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsAlerts',
+                'alertInfoMessage',
+                "Info: {0}",
+                ( notification.message.linkedText.toString())
+            ));
+        }
+        alert(alertText);
+    }
+}
+export { NotificationsAlerts };

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

@@ -0,0 +1,307 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/notificationsCenter.css.js';
+import './media/notificationsActions.css.js';
+import { NOTIFICATIONS_CENTER_BORDER, NOTIFICATIONS_CENTER_HEADER_FOREGROUND, NOTIFICATIONS_CENTER_HEADER_BACKGROUND } from '../../../common/theme.js';
+import { Themable, IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { NotificationActionRunner } from './notificationsCommands.js';
+import { NotificationsList } from './notificationsList.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Dimension, isAncestorOfActiveElement } from '../../../../base/browser/dom.js';
+import { widgetShadow } from '../../../../platform/theme/common/colorRegistry.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { ConfigureDoNotDisturbAction, ToggleDoNotDisturbAction, ToggleDoNotDisturbBySourceAction, ClearAllNotificationsAction, HideNotificationsCenterAction } from './notificationsActions.js';
+import { toAction, Separator } from '../../../../base/common/actions.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { assertIsDefined, assertAllDefined } from '../../../../base/common/types.js';
+import { NotificationsCenterVisibleContext } from '../../../common/contextkeys.js';
+import { NotificationsFilter, INotificationService } from '../../../../platform/notification/common/notification.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { DropdownMenuActionViewItem } from '../../../../base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { AudioCue, IAudioCueService } from '../../../../platform/audioCues/browser/audioCueService.js';
+var NotificationsCenter_1;
+let NotificationsCenter = class NotificationsCenter extends Themable {
+    static { NotificationsCenter_1 = this; }
+    static { this.MAX_DIMENSIONS = ( new Dimension(450, 400)); }
+    static { this.MAX_NOTIFICATION_SOURCES = 10; }
+    constructor(container, model, themeService, instantiationService, layoutService, contextKeyService, editorGroupService, keybindingService, notificationService, audioCueService, contextMenuService) {
+        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.audioCueService = audioCueService;
+        this.contextMenuService = contextMenuService;
+        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.onDidLayoutMainContainer(dimension => this.layout(Dimension.lift(dimension))));
+        this._register(this.notificationService.onDidChangeFilter(() => this.onDidChangeFilter()));
+    }
+    onDidChangeFilter() {
+        if (this.notificationService.getFilter() === NotificationsFilter.ERROR) {
+            this.hide();
+        }
+    }
+    get isVisible() {
+        return !!this._isVisible;
+    }
+    show() {
+        if (this._isVisible) {
+            const notificationsList = assertIsDefined(this.notificationsList);
+            notificationsList.show();
+            notificationsList.focusFirst();
+            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 = ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsCenter',
+                'notificationsEmpty',
+                "No new notifications"
+            ));
+            clearAllAction.enabled = false;
+        }
+        else {
+            notificationsCenterTitle.textContent = ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsCenter',
+                '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 that = this;
+        const notificationsToolBar = this._register(( new ActionBar(toolbarContainer, {
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsCenter',
+                'notificationsToolbar',
+                "Notification Center Actions"
+            )),
+            actionRunner,
+            actionViewItemProvider: action => {
+                if (action.id === ConfigureDoNotDisturbAction.ID) {
+                    return this._register(this.instantiationService.createInstance(DropdownMenuActionViewItem, action, {
+                        getActions() {
+                            const actions = [toAction({
+                                    id: ToggleDoNotDisturbAction.ID,
+                                    label: that.notificationService.getFilter() === NotificationsFilter.OFF ? ( localizeWithPath(
+                                        'vs/workbench/browser/parts/notifications/notificationsCenter',
+                                        'turnOnNotifications',
+                                        "Enable Do Not Disturb Mode"
+                                    )) : ( localizeWithPath(
+                                        'vs/workbench/browser/parts/notifications/notificationsCenter',
+                                        'turnOffNotifications',
+                                        "Disable Do Not Disturb Mode"
+                                    )),
+                                    run: () => that.notificationService.setFilter(that.notificationService.getFilter() === NotificationsFilter.OFF ? NotificationsFilter.ERROR : NotificationsFilter.OFF)
+                                })];
+                            const sortedFilters = that.notificationService.getFilters().sort((a, b) => a.label.localeCompare(b.label));
+                            for (const source of sortedFilters.slice(0, NotificationsCenter_1.MAX_NOTIFICATION_SOURCES)) {
+                                if (actions.length === 1) {
+                                    actions.push(( new Separator()));
+                                }
+                                actions.push(toAction({
+                                    id: `${ToggleDoNotDisturbAction.ID}.${source.id}`,
+                                    label: source.label,
+                                    checked: source.filter !== NotificationsFilter.ERROR,
+                                    run: () => that.notificationService.setFilter({
+                                        ...source,
+                                        filter: source.filter === NotificationsFilter.ERROR ? NotificationsFilter.OFF : NotificationsFilter.ERROR
+                                    })
+                                }));
+                            }
+                            if (sortedFilters.length > NotificationsCenter_1.MAX_NOTIFICATION_SOURCES) {
+                                actions.push(( new Separator()));
+                                actions.push(that._register(that.instantiationService.createInstance(ToggleDoNotDisturbBySourceAction, ToggleDoNotDisturbBySourceAction.ID, ( localizeWithPath(
+                                    'vs/workbench/browser/parts/notifications/notificationsCenter',
+                                    'moreSources',
+                                    "More…"
+                                )))));
+                            }
+                            return actions;
+                        },
+                    }, this.contextMenuService, {
+                        actionRunner,
+                        classNames: action.class,
+                        keybindingProvider: action => this.keybindingService.lookupKeybinding(action.id)
+                    }));
+                }
+                return undefined;
+            }
+        })));
+        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.configureDoNotDisturbAction = this._register(this.instantiationService.createInstance(ConfigureDoNotDisturbAction, ConfigureDoNotDisturbAction.ID, ConfigureDoNotDisturbAction.LABEL));
+        notificationsToolBar.push(this.configureDoNotDisturbAction, { icon: true, label: false });
+        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: ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsCenter',
+                '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 = isAncestorOfActiveElement(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 = isAncestorOfActiveElement(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_1.MAX_DIMENSIONS.width;
+            const maxHeight = NotificationsCenter_1.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" , mainWindow)) {
+                    availableHeight -= 22;
+                }
+                if (this.layoutService.isVisible("workbench.parts.titlebar" , mainWindow)) {
+                    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();
+            }
+            this.audioCueService.playAudioCue(AudioCue.clear);
+        }
+    }
+};
+NotificationsCenter = NotificationsCenter_1 = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IEditorGroupsService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, INotificationService)),
+    ( __param(9, IAudioCueService)),
+    ( __param(10, IContextMenuService))
+], NotificationsCenter));
+export { NotificationsCenter };