@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,185 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/notificationsList.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { trackFocus, isAncestor } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { NOTIFICATIONS_BACKGROUND } from '../../../common/theme.js';
+import { NotificationRenderer, NotificationsListDelegate } from './notificationsViewer.js';
+import { CopyNotificationMessageAction } from './notificationsActions.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { assertIsDefined, assertAllDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { NotificationFocusedContext } from '../../../common/contextkeys.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotificationActionRunner } from './notificationsCommands.js';
+let NotificationsList = class NotificationsList extends Disposable {
+    constructor(container, options, instantiationService, contextMenuService) {
+        super();
+        this.container = container;
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.viewModel = [];
+    }
+    show(focus) {
+        if (this.isVisible) {
+            if (focus) {
+                const list = assertIsDefined(this.list);
+                list.domFocus();
+            }
+            return;
+        }
+        if (!this.list) {
+            this.createNotificationsList();
+        }
+        this.isVisible = true;
+        if (focus) {
+            const list = assertIsDefined(this.list);
+            list.domFocus();
+        }
+    }
+    createNotificationsList() {
+        this.listContainer = document.createElement('div');
+        this.listContainer.classList.add('notifications-list-container');
+        const actionRunner = this._register(this.instantiationService.createInstance(NotificationActionRunner));
+        const renderer = this.instantiationService.createInstance(NotificationRenderer, actionRunner);
+        const listDelegate = this.listDelegate = ( new NotificationsListDelegate(this.listContainer));
+        const options = this.options;
+        const list = this.list = this._register(this.instantiationService.createInstance(WorkbenchList, 'NotificationsList', this.listContainer, listDelegate, [renderer], {
+            ...options,
+            setRowLineHeight: false,
+            horizontalScrolling: false,
+            overrideStyles: {
+                listBackground: NOTIFICATIONS_BACKGROUND
+            },
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (!element.source) {
+                        return ( localize('notificationAriaLabel', "{0}, notification", element.message.raw));
+                    }
+                    return ( localize(
+                        'notificationWithSourceAriaLabel',
+                        "{0}, source: {1}, notification",
+                        element.message.raw,
+                        element.source
+                    ));
+                },
+                getWidgetAriaLabel() {
+                    return options.widgetAriaLabel ?? ( localize('notificationsList', "Notifications List"));
+                },
+                getRole() {
+                    return 'dialog';
+                }
+            }
+        }));
+        const copyAction = this._register(this.instantiationService.createInstance(CopyNotificationMessageAction, CopyNotificationMessageAction.ID, CopyNotificationMessageAction.LABEL));
+        this._register((list.onContextMenu(e => {
+            if (!e.element) {
+                return;
+            }
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => [copyAction],
+                getActionsContext: () => e.element,
+                actionRunner
+            });
+        })));
+        this._register((list.onMouseDblClick(event => event.element.toggle())));
+        const listFocusTracker = this._register(trackFocus(list.getHTMLElement()));
+        this._register(listFocusTracker.onDidBlur(() => {
+            if (document.hasFocus()) {
+                list.setFocus([]);
+            }
+        }));
+        NotificationFocusedContext.bindTo(list.contextKeyService);
+        this._register(list.onDidChangeSelection(e => {
+            if (e.indexes.length > 0) {
+                list.setSelection([]);
+            }
+        }));
+        this.container.appendChild(this.listContainer);
+    }
+    updateNotificationsList(start, deleteCount, items = []) {
+        const [list, listContainer] = assertAllDefined(this.list, this.listContainer);
+        const listHasDOMFocus = isAncestor(document.activeElement, listContainer);
+        const focusedIndex = list.getFocus()[0];
+        const focusedItem = this.viewModel[focusedIndex];
+        let focusRelativeTop = null;
+        if (typeof focusedIndex === 'number') {
+            focusRelativeTop = list.getRelativeTop(focusedIndex);
+        }
+        this.viewModel.splice(start, deleteCount, ...items);
+        list.splice(start, deleteCount, items);
+        list.layout();
+        if (this.viewModel.length === 0) {
+            this.hide();
+        }
+        else if (typeof focusedIndex === 'number') {
+            let indexToFocus = 0;
+            if (focusedItem) {
+                let indexToFocusCandidate = this.viewModel.indexOf(focusedItem);
+                if (indexToFocusCandidate === -1) {
+                    indexToFocusCandidate = focusedIndex - 1;
+                }
+                if (indexToFocusCandidate < this.viewModel.length && indexToFocusCandidate >= 0) {
+                    indexToFocus = indexToFocusCandidate;
+                }
+            }
+            if (typeof focusRelativeTop === 'number') {
+                list.reveal(indexToFocus, focusRelativeTop);
+            }
+            list.setFocus([indexToFocus]);
+        }
+        if (this.isVisible && listHasDOMFocus) {
+            list.domFocus();
+        }
+    }
+    updateNotificationHeight(item) {
+        const index = this.viewModel.indexOf(item);
+        if (index === -1) {
+            return;
+        }
+        const [list, listDelegate] = assertAllDefined(this.list, this.listDelegate);
+        list.updateElementHeight(index, listDelegate.getHeight(item));
+        list.layout();
+    }
+    hide() {
+        if (!this.isVisible || !this.list) {
+            return;
+        }
+        this.isVisible = false;
+        this.list.splice(0, this.viewModel.length);
+        this.viewModel = [];
+    }
+    focusFirst() {
+        if (!this.isVisible || !this.list) {
+            return;
+        }
+        this.list.focusFirst();
+        this.list.domFocus();
+    }
+    hasFocus() {
+        if (!this.isVisible || !this.listContainer) {
+            return false;
+        }
+        return isAncestor(document.activeElement, this.listContainer);
+    }
+    layout(width, maxHeight) {
+        if (this.listContainer && this.list) {
+            this.listContainer.style.width = `${width}px`;
+            if (typeof maxHeight === 'number') {
+                this.list.getHTMLElement().style.maxHeight = `${maxHeight}px`;
+            }
+            this.list.layout();
+        }
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+};
+NotificationsList = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextMenuService))
+], NotificationsList));
+export { NotificationsList };

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

@@ -0,0 +1,35 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotificationPriority, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+function notificationToMetrics(message, source, silent) {
+    return {
+        id: ( hash(( message.toString())).toString()),
+        silent,
+        source: source || 'core'
+    };
+}
+let NotificationsTelemetry = class NotificationsTelemetry extends Disposable {
+    constructor(telemetryService, notificationService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.notificationService.onDidAddNotification(notification => {
+            const source = notification.source && typeof notification.source !== 'string' ? notification.source.id : notification.source;
+            this.telemetryService.publicLog2('notification:show', notificationToMetrics(notification.message, source, notification.priority === NotificationPriority.SILENT));
+        }));
+        this._register(this.notificationService.onDidRemoveNotification(notification => {
+            const source = notification.source && typeof notification.source !== 'string' ? notification.source.id : notification.source;
+            this.telemetryService.publicLog2('notification:close', notificationToMetrics(notification.message, source, notification.priority === NotificationPriority.SILENT));
+        }));
+    }
+};
+NotificationsTelemetry = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, INotificationService))
+], NotificationsTelemetry));
+export { NotificationsTelemetry, notificationToMetrics };

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

@@ -0,0 +1,417 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/notificationsToasts.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Dimension, scheduleAtNextAnimationFrame, addDisposableListener, EventType, isAncestor } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { NotificationsList } from './notificationsList.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { NOTIFICATIONS_BACKGROUND, NOTIFICATIONS_TOAST_BORDER } from '../../../common/theme.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { widgetShadow } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Severity, NotificationsFilter, NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { IntervalCounter } from 'monaco-editor/esm/vs/base/common/async.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { NotificationsToastsVisibleContext } from '../../../common/contextkeys.js';
+var ToastVisibility;
+( (function(ToastVisibility) {
+    ToastVisibility[ToastVisibility["HIDDEN_OR_VISIBLE"] = 0] = "HIDDEN_OR_VISIBLE";
+    ToastVisibility[ToastVisibility["HIDDEN"] = 1] = "HIDDEN";
+    ToastVisibility[ToastVisibility["VISIBLE"] = 2] = "VISIBLE";
+})(ToastVisibility || (ToastVisibility = {})));
+let NotificationsToasts = class NotificationsToasts extends Themable {
+    get isVisible() { return !!this._isVisible; }
+    constructor(container, model, instantiationService, layoutService, themeService, editorGroupService, contextKeyService, lifecycleService, hostService) {
+        super(themeService);
+        this.container = container;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.editorGroupService = editorGroupService;
+        this.contextKeyService = contextKeyService;
+        this.lifecycleService = lifecycleService;
+        this.hostService = hostService;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._isVisible = false;
+        this.mapNotificationToToast = ( new Map());
+        this.mapNotificationToDisposable = ( new Map());
+        this.notificationsToastsVisibleContextKey = NotificationsToastsVisibleContext.bindTo(this.contextKeyService);
+        this.addedToastsIntervalCounter = ( new IntervalCounter(NotificationsToasts.SPAM_PROTECTION.interval));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.layoutService.onDidLayout(dimension => this.layout(Dimension.lift(dimension))));
+        this.lifecycleService.when(3 ).then(() => {
+            this.model.notifications.forEach(notification => this.addToast(notification));
+            this._register(this.model.onDidChangeNotification(e => this.onDidChangeNotification(e)));
+        });
+        this._register(this.model.onDidChangeFilter(filter => {
+            if (filter === NotificationsFilter.SILENT || filter === NotificationsFilter.ERROR) {
+                this.hide();
+            }
+        }));
+    }
+    onDidChangeNotification(e) {
+        switch (e.kind) {
+            case 0 :
+                return this.addToast(e.item);
+            case 3 :
+                return this.removeToast(e.item);
+        }
+    }
+    addToast(item) {
+        if (this.isNotificationsCenterVisible) {
+            return;
+        }
+        if (item.priority === NotificationPriority.SILENT) {
+            return;
+        }
+        if (this.addedToastsIntervalCounter.increment() > NotificationsToasts.SPAM_PROTECTION.limit) {
+            return;
+        }
+        const itemDisposables = ( new DisposableStore());
+        this.mapNotificationToDisposable.set(item, itemDisposables);
+        itemDisposables.add(scheduleAtNextAnimationFrame(() => this.doAddToast(item, itemDisposables)));
+    }
+    doAddToast(item, itemDisposables) {
+        let notificationsToastsContainer = this.notificationsToastsContainer;
+        if (!notificationsToastsContainer) {
+            notificationsToastsContainer = this.notificationsToastsContainer = document.createElement('div');
+            notificationsToastsContainer.classList.add('notifications-toasts');
+            this.container.appendChild(notificationsToastsContainer);
+        }
+        notificationsToastsContainer.classList.add('visible');
+        const notificationToastContainer = document.createElement('div');
+        notificationToastContainer.classList.add('notification-toast-container');
+        const firstToast = notificationsToastsContainer.firstChild;
+        if (firstToast) {
+            notificationsToastsContainer.insertBefore(notificationToastContainer, firstToast);
+        }
+        else {
+            notificationsToastsContainer.appendChild(notificationToastContainer);
+        }
+        const notificationToast = document.createElement('div');
+        notificationToast.classList.add('notification-toast');
+        notificationToastContainer.appendChild(notificationToast);
+        const notificationList = this.instantiationService.createInstance(NotificationsList, notificationToast, {
+            verticalScrollMode: 2 ,
+            widgetAriaLabel: (() => {
+                if (!item.source) {
+                    return ( localize('notificationAriaLabel', "{0}, notification", item.message.raw));
+                }
+                return ( localize(
+                    'notificationWithSourceAriaLabel',
+                    "{0}, source: {1}, notification",
+                    item.message.raw,
+                    item.source
+                ));
+            })()
+        });
+        itemDisposables.add(notificationList);
+        const toast = { item, list: notificationList, container: notificationToastContainer, toast: notificationToast };
+        this.mapNotificationToToast.set(item, toast);
+        itemDisposables.add(toDisposable(() => this.updateToastVisibility(toast, false)));
+        notificationList.show();
+        const maxDimensions = this.computeMaxDimensions();
+        this.layoutLists(maxDimensions.width);
+        notificationList.updateNotificationsList(0, 0, [item]);
+        this.layoutContainer(maxDimensions.height);
+        itemDisposables.add(item.onDidChangeExpansion(() => {
+            notificationList.updateNotificationsList(0, 1, [item]);
+        }));
+        itemDisposables.add(item.onDidChangeContent(e => {
+            switch (e.kind) {
+                case 2 :
+                    notificationList.updateNotificationsList(0, 1, [item]);
+                    break;
+                case 1 :
+                    if (item.expanded) {
+                        notificationList.updateNotificationHeight(item);
+                    }
+                    break;
+            }
+        }));
+        Event.once(item.onDidClose)(() => {
+            this.removeToast(item);
+        });
+        this.purgeNotification(item, notificationToastContainer, notificationList, itemDisposables);
+        this.updateStyles();
+        this.notificationsToastsVisibleContextKey.set(true);
+        notificationToast.classList.add('notification-fade-in');
+        itemDisposables.add(addDisposableListener(notificationToast, 'transitionend', () => {
+            notificationToast.classList.remove('notification-fade-in');
+            notificationToast.classList.add('notification-fade-in-done');
+        }));
+        item.updateVisibility(true);
+        if (!this._isVisible) {
+            this._isVisible = true;
+            this._onDidChangeVisibility.fire();
+        }
+    }
+    purgeNotification(item, notificationToastContainer, notificationList, disposables) {
+        let isMouseOverToast = false;
+        disposables.add(addDisposableListener(notificationToastContainer, EventType.MOUSE_OVER, () => isMouseOverToast = true));
+        disposables.add(addDisposableListener(notificationToastContainer, EventType.MOUSE_OUT, () => isMouseOverToast = false));
+        let purgeTimeoutHandle;
+        let listener;
+        const hideAfterTimeout = () => {
+            purgeTimeoutHandle = setTimeout(() => {
+                if (!this.hostService.hasFocus) {
+                    if (!listener) {
+                        listener = this.hostService.onDidChangeFocus(focus => {
+                            if (focus) {
+                                hideAfterTimeout();
+                            }
+                        });
+                        disposables.add(listener);
+                    }
+                }
+                else if (item.sticky ||
+                    notificationList.hasFocus() ||
+                    isMouseOverToast
+                ) {
+                    hideAfterTimeout();
+                }
+                else {
+                    this.removeToast(item);
+                }
+            }, NotificationsToasts.PURGE_TIMEOUT[item.severity]);
+        };
+        hideAfterTimeout();
+        disposables.add(toDisposable(() => clearTimeout(purgeTimeoutHandle)));
+    }
+    removeToast(item) {
+        let focusEditor = false;
+        const notificationToast = this.mapNotificationToToast.get(item);
+        if (notificationToast) {
+            const toastHasDOMFocus = isAncestor(document.activeElement, notificationToast.container);
+            if (toastHasDOMFocus) {
+                focusEditor = !(this.focusNext() || this.focusPrevious());
+            }
+            this.mapNotificationToToast.delete(item);
+        }
+        const notificationDisposables = this.mapNotificationToDisposable.get(item);
+        if (notificationDisposables) {
+            dispose(notificationDisposables);
+            this.mapNotificationToDisposable.delete(item);
+        }
+        if (this.mapNotificationToToast.size > 0) {
+            this.layout(this.workbenchDimensions);
+        }
+        else {
+            this.doHide();
+            if (focusEditor) {
+                this.editorGroupService.activeGroup.focus();
+            }
+        }
+    }
+    removeToasts() {
+        this.mapNotificationToToast.clear();
+        this.mapNotificationToDisposable.forEach(disposable => dispose(disposable));
+        this.mapNotificationToDisposable.clear();
+        this.doHide();
+    }
+    doHide() {
+        this.notificationsToastsContainer?.classList.remove('visible');
+        this.notificationsToastsVisibleContextKey.set(false);
+        if (this._isVisible) {
+            this._isVisible = false;
+            this._onDidChangeVisibility.fire();
+        }
+    }
+    hide() {
+        const focusEditor = this.notificationsToastsContainer ? isAncestor(document.activeElement, this.notificationsToastsContainer) : false;
+        this.removeToasts();
+        if (focusEditor) {
+            this.editorGroupService.activeGroup.focus();
+        }
+    }
+    focus() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        if (toasts.length > 0) {
+            toasts[0].list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    focusNext() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        for (let i = 0; i < toasts.length; i++) {
+            const toast = toasts[i];
+            if (toast.list.hasFocus()) {
+                const nextToast = toasts[i + 1];
+                if (nextToast) {
+                    nextToast.list.focusFirst();
+                    return true;
+                }
+                break;
+            }
+        }
+        return false;
+    }
+    focusPrevious() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        for (let i = 0; i < toasts.length; i++) {
+            const toast = toasts[i];
+            if (toast.list.hasFocus()) {
+                const previousToast = toasts[i - 1];
+                if (previousToast) {
+                    previousToast.list.focusFirst();
+                    return true;
+                }
+                break;
+            }
+        }
+        return false;
+    }
+    focusFirst() {
+        const toast = this.getToasts(ToastVisibility.VISIBLE)[0];
+        if (toast) {
+            toast.list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    focusLast() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        if (toasts.length > 0) {
+            toasts[toasts.length - 1].list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    update(isCenterVisible) {
+        if (this.isNotificationsCenterVisible !== isCenterVisible) {
+            this.isNotificationsCenterVisible = isCenterVisible;
+            if (this.isNotificationsCenterVisible) {
+                this.removeToasts();
+            }
+        }
+    }
+    updateStyles() {
+        this.mapNotificationToToast.forEach(({ toast }) => {
+            const backgroundColor = this.getColor(NOTIFICATIONS_BACKGROUND);
+            toast.style.background = backgroundColor ? backgroundColor : '';
+            const widgetShadowColor = this.getColor(widgetShadow);
+            toast.style.boxShadow = widgetShadowColor ? `0 0 8px 2px ${widgetShadowColor}` : '';
+            const borderColor = this.getColor(NOTIFICATIONS_TOAST_BORDER);
+            toast.style.border = borderColor ? `1px solid ${borderColor}` : '';
+        });
+    }
+    getToasts(state) {
+        const notificationToasts = [];
+        this.mapNotificationToToast.forEach(toast => {
+            switch (state) {
+                case ToastVisibility.HIDDEN_OR_VISIBLE:
+                    notificationToasts.push(toast);
+                    break;
+                case ToastVisibility.HIDDEN:
+                    if (!this.isToastInDOM(toast)) {
+                        notificationToasts.push(toast);
+                    }
+                    break;
+                case ToastVisibility.VISIBLE:
+                    if (this.isToastInDOM(toast)) {
+                        notificationToasts.push(toast);
+                    }
+                    break;
+            }
+        });
+        return notificationToasts.reverse();
+    }
+    layout(dimension) {
+        this.workbenchDimensions = dimension;
+        const maxDimensions = this.computeMaxDimensions();
+        if (maxDimensions.height) {
+            this.layoutContainer(maxDimensions.height);
+        }
+        this.layoutLists(maxDimensions.width);
+    }
+    computeMaxDimensions() {
+        const maxWidth = NotificationsToasts.MAX_WIDTH;
+        let availableWidth = maxWidth;
+        let availableHeight;
+        if (this.workbenchDimensions) {
+            availableWidth = this.workbenchDimensions.width;
+            availableWidth -= (2 * 8);
+            availableHeight = this.workbenchDimensions.height;
+            if (this.layoutService.isVisible("workbench.parts.statusbar" )) {
+                availableHeight -= 22;
+            }
+            if (this.layoutService.isVisible("workbench.parts.titlebar" )) {
+                availableHeight -= 22;
+            }
+            availableHeight -= (2 * 12);
+        }
+        availableHeight = typeof availableHeight === 'number'
+            ? Math.round(availableHeight * 0.618)
+            : 0;
+        return ( new Dimension(Math.min(maxWidth, availableWidth), availableHeight));
+    }
+    layoutLists(width) {
+        this.mapNotificationToToast.forEach(({ list }) => list.layout(width));
+    }
+    layoutContainer(heightToGive) {
+        let visibleToasts = 0;
+        for (const toast of this.getToasts(ToastVisibility.HIDDEN_OR_VISIBLE)) {
+            toast.container.style.opacity = '0';
+            this.updateToastVisibility(toast, true);
+            heightToGive -= toast.container.offsetHeight;
+            let makeVisible = false;
+            if (visibleToasts === NotificationsToasts.MAX_NOTIFICATIONS) {
+                makeVisible = false;
+            }
+            else if (heightToGive >= 0) {
+                makeVisible = true;
+            }
+            this.updateToastVisibility(toast, makeVisible);
+            toast.container.style.opacity = '';
+            if (makeVisible) {
+                visibleToasts++;
+            }
+        }
+    }
+    updateToastVisibility(toast, visible) {
+        if (this.isToastInDOM(toast) === visible) {
+            return;
+        }
+        const notificationsToastsContainer = assertIsDefined(this.notificationsToastsContainer);
+        if (visible) {
+            notificationsToastsContainer.appendChild(toast.container);
+        }
+        else {
+            notificationsToastsContainer.removeChild(toast.container);
+        }
+        toast.item.updateVisibility(visible);
+    }
+    isToastInDOM(toast) {
+        return !!toast.container.parentElement;
+    }
+};
+NotificationsToasts.MAX_WIDTH = 450;
+NotificationsToasts.MAX_NOTIFICATIONS = 3;
+NotificationsToasts.PURGE_TIMEOUT = {
+    [Severity.Info]: 15000,
+    [Severity.Warning]: 18000,
+    [Severity.Error]: 20000
+};
+NotificationsToasts.SPAM_PROTECTION = {
+    interval: 800,
+    limit: NotificationsToasts.MAX_NOTIFICATIONS
+};
+NotificationsToasts = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, ILifecycleService)),
+    ( __param(8, IHostService))
+], NotificationsToasts));
+export { NotificationsToasts };