@codingame/monaco-vscode-notifications-service-override 1.82.4 → 1.82.5-next.0

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -1 +1 @@
-export { default } from 'vscode/service-override/notifications'
+export { default } from './notifications.js';

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/notifications'
+export { default } from './notifications.js';

package/notifications.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(container?: HTMLElement): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/notifications.js

@@ -0,0 +1,35 @@
+import { NotificationsToasts } from './vscode/src/vs/workbench/browser/parts/notifications/notificationsToasts.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { NotificationService } from './vscode/src/vs/workbench/services/notification/common/notificationService.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { registerNotificationCommands } from 'vscode/vscode/vs/workbench/browser/parts/notifications/notificationsCommands';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { NotificationsCenter } from './vscode/src/vs/workbench/browser/parts/notifications/notificationsCenter.js';
+import { NotificationsAlerts } from './vscode/src/vs/workbench/browser/parts/notifications/notificationsAlerts.js';
+import { NotificationsTelemetry } from 'vscode/vscode/vs/workbench/browser/parts/notifications/notificationsTelemetry';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import getServiceOverride$1 from 'vscode/service-override/layout';
+import { onRenderWorkbench } from 'vscode/lifecycle';
+
+onRenderWorkbench(async (accessor) => {
+    const container = accessor.get(ILayoutService).container;
+    const model = accessor.get(INotificationService).model;
+    const instantiationService = accessor.get(IInstantiationService);
+    setTimeout(() => {
+        const notificationsCenter = instantiationService.createInstance(NotificationsCenter, container, model);
+        const notificationsToasts = instantiationService.createInstance(NotificationsToasts, container, model);
+        instantiationService.createInstance(NotificationsAlerts, model);
+        instantiationService.createInstance(NotificationsTelemetry);
+        registerNotificationCommands(notificationsCenter, notificationsToasts, model);
+        notificationsToasts.layout(dom.getClientArea(container));
+    });
+});
+function getServiceOverride(container) {
+    return {
+        [( INotificationService.toString())]: new SyncDescriptor(NotificationService, undefined, true),
+        ...getServiceOverride$1(container)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-notifications-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.0",
     "monaco-editor": "0.43.0"
   }
 }

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

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container .action-item,.monaco-workbench>.notifications-center>.notifications-center-header>.notifications-center-header-toolbar .action-item{margin-right:4px}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container .action-item:first-child,.monaco-workbench>.notifications-center>.notifications-center-header>.notifications-center-header-toolbar .action-item:first-child{margin-left:4px}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench>.notifications-center{border-radius:4px;bottom:31px;display:none;overflow:hidden;position:absolute;right:8px;z-index:1000}.monaco-workbench.nostatusbar>.notifications-center{bottom:8px}.monaco-workbench>.notifications-center.visible{display:block}.monaco-workbench>.notifications-center>.notifications-center-header{align-items:center;display:flex;height:35px;padding-left:8px;padding-right:5px}.monaco-workbench>.notifications-center>.notifications-center-header>.notifications-center-header-title{font-size:11px;text-transform:uppercase}.monaco-workbench>.notifications-center>.notifications-center-header>.notifications-center-header-toolbar{flex:1}.monaco-workbench>.notifications-center>.notifications-center-header>.notifications-center-header-toolbar .actions-container{justify-content:flex-end}.monaco-workbench>.notifications-center .notifications-list-container .monaco-list-row[data-last-element=false]>.notification-list-item{border-bottom:1px solid var(--vscode-notifications-border)}.monaco-workbench>.notifications-center .notifications-list-container,.monaco-workbench>.notifications-center .notifications-list-container .monaco-scrollable-element,.monaco-workbench>.notifications-center .notifications-list-container .notification-list-item{border-radius:0}.monaco-workbench>.notifications-center .codicon.codicon-error{color:var(--vscode-notificationsErrorIcon-foreground)!important}.monaco-workbench>.notifications-center .codicon.codicon-warning{color:var(--vscode-notificationsWarningIcon-foreground)!important}.monaco-workbench>.notifications-center .codicon.codicon-info{color:var(--vscode-notificationsInfoIcon-foreground)!important}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/browser/parts/notifications/media/notificationsList.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .notifications-list-container{background:var(--vscode-notifications-background);border-radius:inherit;color:var(--vscode-notifications-foreground);outline-color:var(--vscode-contrastBorder)}.monaco-workbench .notifications-list-container .notification-list-item{border-radius:4px;box-sizing:border-box;display:flex;flex-direction:column;flex-direction:column-reverse;height:100%;padding:10px 5px}.monaco-workbench .notifications-list-container .notification-offset-helper{word-wrap:break-word;line-height:22px;opacity:0;position:absolute}.monaco-workbench .notifications-list-container .monaco-scrollable-element{border-radius:4px}.monaco-workbench .notifications-list-container .notification-list-item>.notification-list-item-main-row{display:flex;flex-grow:1}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-icon{align-items:center;background-position:50%;background-repeat:no-repeat;display:flex;flex:0 0 16px;font-size:18px;height:22px;margin-left:4px;margin-right:4px}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message{flex:1;line-height:22px;overflow:hidden;text-overflow:ellipsis;user-select:text;-webkit-user-select:text}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message a{color:var(--vscode-notificationLink-foreground)}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message a:focus{outline-color:var(--vscode-focusBorder);outline-style:solid;outline-width:1px}.monaco-workbench .notifications-list-container .notification-list-item.expanded .notification-list-item-message{word-wrap:break-word;white-space:normal}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container{display:none;height:22px}.monaco-workbench .notifications-list-container .monaco-list-row.focused .notification-list-item .notification-list-item-toolbar-container,.monaco-workbench .notifications-list-container .monaco-list:focus-within .notification-list-item .notification-list-item-toolbar-container,.monaco-workbench .notifications-list-container .notification-list-item.expanded .notification-list-item-toolbar-container,.monaco-workbench .notifications-list-container .notification-list-item:hover .notification-list-item-toolbar-container{display:block}.monaco-workbench .notifications-list-container .notification-list-item>.notification-list-item-details-row{align-items:center;display:none;overflow:hidden;padding-left:5px}.monaco-workbench .notifications-list-container .notification-list-item.expanded>.notification-list-item-details-row{display:flex}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-source{flex:1;font-size:12px;overflow:hidden;text-overflow:ellipsis}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container{display:flex;overflow:hidden}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container>.monaco-button,.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container>.monaco-button-dropdown{margin:4px 5px}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-button{outline-offset:2px!important}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-text-button{display:inline-block;font-size:12px;overflow:hidden;padding:4px 10px;text-overflow:ellipsis;width:fit-content}.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-dropdown-button{padding:5px}.monaco-workbench .notifications-list-container .progress-bit{bottom:0;height:2px}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/browser/parts/notifications/media/notificationsToasts.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench>.notifications-toasts{bottom:26px;display:none;overflow:hidden;position:absolute;right:3px;z-index:1000}.monaco-workbench.nostatusbar>.notifications-toasts{bottom:3px}.monaco-workbench>.notifications-toasts.visible{display:flex;flex-direction:column}.monaco-workbench>.notifications-toasts .notification-toast-container{overflow:hidden}.monaco-workbench>.notifications-toasts .notification-toast-container>.notification-toast{border-radius:4px;margin:8px;opacity:0;transform:translate3d(0,100%,0);transition:transform .3s ease-out,opacity .3s ease-out}.monaco-workbench.reduce-motion>.notifications-toasts .notification-toast-container>.notification-toast{transition:transform 0ms ease-out,opacity 0ms ease-out}.monaco-workbench>.notifications-toasts .notification-toast-container>.notification-toast.notification-fade-in{opacity:1;transform:none}.monaco-workbench>.notifications-toasts .notification-toast-container>.notification-toast.notification-fade-in-done{opacity:1;transform:none;transition:none}.monaco-workbench>.notifications-toasts .codicon.codicon-error{color:var(--vscode-notificationsErrorIcon-foreground)!important}.monaco-workbench>.notifications-toasts .codicon.codicon-warning{color:var(--vscode-notificationsWarningIcon-foreground)!important}.monaco-workbench>.notifications-toasts .codicon.codicon-info{color:var(--vscode-notificationsInfoIcon-foreground)!important}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,126 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/notificationsActions.css.js';
+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 'vscode/vscode/vs/workbench/browser/parts/notifications/notificationsCommands';
+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 {
+    static { this.ID = CLEAR_NOTIFICATION; }
+    static { this.LABEL = ( localize('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 = ( localize('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 = ( localize('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 HideNotificationsCenterAction = class HideNotificationsCenterAction extends Action {
+    static { this.ID = HIDE_NOTIFICATIONS_CENTER; }
+    static { this.LABEL = ( localize('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 = ( localize('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 = ( localize('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 = ( localize('configureNotification', "More Actions...")); }
+    constructor(id, label, configurationActions) {
+        super(id, label, ThemeIcon.asClassName(configureIcon));
+        this.configurationActions = configurationActions;
+    }
+}
+let CopyNotificationMessageAction = class CopyNotificationMessageAction extends Action {
+    static { this.ID = 'workbench.action.copyNotificationMessage'; }
+    static { this.LABEL = ( localize('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, ConfigureNotificationAction, CopyNotificationMessageAction, ExpandNotificationAction, HideNotificationsCenterAction, ToggleDoNotDisturbAction };

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

@@ -0,0 +1,60 @@
+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/vscode/src/vs/workbench/browser/parts/notifications/notificationsCenter.js

@@ -0,0 +1,229 @@
+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 'vscode/vscode/vs/workbench/common/theme';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+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 'vscode/vscode/vs/workbench/browser/parts/notifications/notificationsCommands';
+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 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+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 'vscode/vscode/vs/workbench/common/contextkeys';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+
+var NotificationsCenter_1;
+let NotificationsCenter = class NotificationsCenter extends Themable {
+    static { NotificationsCenter_1 = this; }
+    static { this.MAX_DIMENSIONS = ( new Dimension(450, 400)); }
+    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();
+            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 = ( 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_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" )) {
+                    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 = NotificationsCenter_1 = ( __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 };