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

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

@@ -0,0 +1,226 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/notificationsList.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { trackFocus, getWindow, isAncestorOfActiveElement } from '../../../../base/browser/dom.js';
+import { WorkbenchList } from '../../../../platform/list/browser/listService.js';
+import { IInstantiationService } from '../../../../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 '../../../../platform/contextview/browser/contextView.js';
+import { assertAllDefined } from '../../../../base/common/types.js';
+import { NotificationFocusedContext } from '../../../common/contextkeys.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { NotificationActionRunner } from './notificationsCommands.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.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() {
+        if (this.isVisible) {
+            return;
+        }
+        if (!this.list) {
+            this.createNotificationsList();
+        }
+        this.isVisible = true;
+    }
+    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: this.instantiationService.createInstance(NotificationAccessibilityProvider, options)
+        }));
+        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 (getWindow(this.listContainer).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 = isAncestorOfActiveElement(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.list) {
+            return;
+        }
+        this.list.focusFirst();
+        this.list.domFocus();
+    }
+    hasFocus() {
+        if (!this.listContainer) {
+            return false;
+        }
+        return isAncestorOfActiveElement(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));
+let NotificationAccessibilityProvider = class NotificationAccessibilityProvider {
+    constructor(_options, _keybindingService, _configurationService) {
+        this._options = _options;
+        this._keybindingService = _keybindingService;
+        this._configurationService = _configurationService;
+    }
+    getAriaLabel(element) {
+        let accessibleViewHint;
+        const keybinding = this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel();
+        if (this._configurationService.getValue('accessibility.verbosity.notification')) {
+            accessibleViewHint = keybinding ? ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsList',
+                'notificationAccessibleViewHint',
+                "Inspect the response in the accessible view with {0}",
+                keybinding
+            )) : ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsList',
+                'notificationAccessibleViewHintNoKb',
+                "Inspect the response in the accessible view via the command Open Accessible View which is currently not triggerable via keybinding"
+            ));
+        }
+        if (!element.source) {
+            return accessibleViewHint ? ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsList',
+                'notificationAriaLabelHint',
+                "{0}, notification, {1}",
+                element.message.raw,
+                accessibleViewHint
+            )) : ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsList',
+                'notificationAriaLabel',
+                "{0}, notification",
+                element.message.raw
+            ));
+        }
+        return accessibleViewHint ? ( localizeWithPath(
+            'vs/workbench/browser/parts/notifications/notificationsList',
+            'notificationWithSourceAriaLabelHint',
+            "{0}, source: {1}, notification, {2}",
+            element.message.raw,
+            element.source,
+            accessibleViewHint
+        )) : ( localizeWithPath(
+            'vs/workbench/browser/parts/notifications/notificationsList',
+            'notificationWithSourceAriaLabel',
+            "{0}, source: {1}, notification",
+            element.message.raw,
+            element.source
+        ));
+    }
+    getWidgetAriaLabel() {
+        return this._options.widgetAriaLabel ?? ( localizeWithPath(
+            'vs/workbench/browser/parts/notifications/notificationsList',
+            'notificationsList',
+            "Notifications List"
+        ));
+    }
+    getRole() {
+        return 'dialog';
+    }
+};
+NotificationAccessibilityProvider = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IConfigurationService))
+], NotificationAccessibilityProvider));
+export { NotificationsList };

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

@@ -0,0 +1,218 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { Disposable, dispose } from '../../../../base/common/lifecycle.js';
+import { HIDE_NOTIFICATIONS_CENTER, SHOW_NOTIFICATIONS_CENTER } from './notificationsCommands.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { NotificationsFilter, INotificationService } from '../../../../platform/notification/common/notification.js';
+let NotificationsStatus = class NotificationsStatus extends Disposable {
+    constructor(model, statusbarService, notificationService) {
+        super();
+        this.model = model;
+        this.statusbarService = statusbarService;
+        this.notificationService = notificationService;
+        this.newNotificationsCount = 0;
+        this.isNotificationsCenterVisible = false;
+        this.isNotificationsToastsVisible = false;
+        this.updateNotificationsCenterStatusItem();
+        if (model.statusMessage) {
+            this.doSetStatusMessage(model.statusMessage);
+        }
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.model.onDidChangeNotification(e => this.onDidChangeNotification(e)));
+        this._register(this.model.onDidChangeStatusMessage(e => this.onDidChangeStatusMessage(e)));
+        this._register(this.notificationService.onDidChangeFilter(() => this.updateNotificationsCenterStatusItem()));
+    }
+    onDidChangeNotification(e) {
+        if (!this.isNotificationsCenterVisible) {
+            if (e.kind === 0 ) {
+                this.newNotificationsCount++;
+            }
+            else if (e.kind === 3  && this.newNotificationsCount > 0) {
+                this.newNotificationsCount--;
+            }
+        }
+        this.updateNotificationsCenterStatusItem();
+    }
+    updateNotificationsCenterStatusItem() {
+        let notificationsInProgress = 0;
+        if (!this.isNotificationsCenterVisible && !this.isNotificationsToastsVisible) {
+            for (const notification of this.model.notifications) {
+                if (notification.hasProgress) {
+                    notificationsInProgress++;
+                }
+            }
+        }
+        let statusProperties = {
+            name: ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                'status.notifications',
+                "Notifications"
+            )),
+            text: `${notificationsInProgress > 0 || this.newNotificationsCount > 0 ? '$(bell-dot)' : '$(bell)'}`,
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                'status.notifications',
+                "Notifications"
+            )),
+            command: this.isNotificationsCenterVisible ? HIDE_NOTIFICATIONS_CENTER : SHOW_NOTIFICATIONS_CENTER,
+            tooltip: this.getTooltip(notificationsInProgress),
+            showBeak: this.isNotificationsCenterVisible
+        };
+        if (this.notificationService.getFilter() === NotificationsFilter.ERROR) {
+            statusProperties = {
+                ...statusProperties,
+                text: `${notificationsInProgress > 0 || this.newNotificationsCount > 0 ? '$(bell-slash-dot)' : '$(bell-slash)'}`,
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/browser/parts/notifications/notificationsStatus',
+                    'status.doNotDisturb',
+                    "Do Not Disturb"
+                )),
+                tooltip: ( localizeWithPath(
+                    'vs/workbench/browser/parts/notifications/notificationsStatus',
+                    'status.doNotDisturbTooltip',
+                    "Do Not Disturb Mode is Enabled"
+                ))
+            };
+        }
+        if (!this.notificationsCenterStatusItem) {
+            this.notificationsCenterStatusItem = this.statusbarService.addEntry(statusProperties, 'status.notifications', 1 , -Number.MAX_VALUE );
+        }
+        else {
+            this.notificationsCenterStatusItem.update(statusProperties);
+        }
+    }
+    getTooltip(notificationsInProgress) {
+        if (this.isNotificationsCenterVisible) {
+            return ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                'hideNotifications',
+                "Hide Notifications"
+            ));
+        }
+        if (this.model.notifications.length === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                'zeroNotifications',
+                "No Notifications"
+            ));
+        }
+        if (notificationsInProgress === 0) {
+            if (this.newNotificationsCount === 0) {
+                return ( localizeWithPath(
+                    'vs/workbench/browser/parts/notifications/notificationsStatus',
+                    'noNotifications',
+                    "No New Notifications"
+                ));
+            }
+            if (this.newNotificationsCount === 1) {
+                return ( localizeWithPath(
+                    'vs/workbench/browser/parts/notifications/notificationsStatus',
+                    'oneNotification',
+                    "1 New Notification"
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                { key: 'notifications', comment: ['{0} will be replaced by a number'] },
+                "{0} New Notifications",
+                this.newNotificationsCount
+            ));
+        }
+        if (this.newNotificationsCount === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                { key: 'noNotificationsWithProgress', comment: ['{0} will be replaced by a number'] },
+                "No New Notifications ({0} in progress)",
+                notificationsInProgress
+            ));
+        }
+        if (this.newNotificationsCount === 1) {
+            return ( localizeWithPath(
+                'vs/workbench/browser/parts/notifications/notificationsStatus',
+                { key: 'oneNotificationWithProgress', comment: ['{0} will be replaced by a number'] },
+                "1 New Notification ({0} in progress)",
+                notificationsInProgress
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/workbench/browser/parts/notifications/notificationsStatus',
+            { key: 'notificationsWithProgress', comment: ['{0} and {1} will be replaced by a number'] },
+            "{0} New Notifications ({1} in progress)",
+            this.newNotificationsCount,
+            notificationsInProgress
+        ));
+    }
+    update(isCenterVisible, isToastsVisible) {
+        let updateNotificationsCenterStatusItem = false;
+        if (this.isNotificationsCenterVisible !== isCenterVisible) {
+            this.isNotificationsCenterVisible = isCenterVisible;
+            this.newNotificationsCount = 0;
+            updateNotificationsCenterStatusItem = true;
+        }
+        if (this.isNotificationsToastsVisible !== isToastsVisible) {
+            this.isNotificationsToastsVisible = isToastsVisible;
+            updateNotificationsCenterStatusItem = true;
+        }
+        if (updateNotificationsCenterStatusItem) {
+            this.updateNotificationsCenterStatusItem();
+        }
+    }
+    onDidChangeStatusMessage(e) {
+        const statusItem = e.item;
+        switch (e.kind) {
+            case 0 :
+                this.doSetStatusMessage(statusItem);
+                break;
+            case 1 :
+                if (this.currentStatusMessage && this.currentStatusMessage[0] === statusItem) {
+                    dispose(this.currentStatusMessage[1]);
+                    this.currentStatusMessage = undefined;
+                }
+                break;
+        }
+    }
+    doSetStatusMessage(item) {
+        const message = item.message;
+        const showAfter = item.options && typeof item.options.showAfter === 'number' ? item.options.showAfter : 0;
+        const hideAfter = item.options && typeof item.options.hideAfter === 'number' ? item.options.hideAfter : -1;
+        if (this.currentStatusMessage) {
+            dispose(this.currentStatusMessage[1]);
+        }
+        let statusMessageEntry;
+        let showHandle = setTimeout(() => {
+            statusMessageEntry = this.statusbarService.addEntry({
+                name: ( localizeWithPath(
+                    'vs/workbench/browser/parts/notifications/notificationsStatus',
+                    'status.message',
+                    "Status Message"
+                )),
+                text: message,
+                ariaLabel: message
+            }, 'status.message', 0 , -Number.MAX_VALUE );
+            showHandle = null;
+        }, showAfter);
+        let hideHandle;
+        const statusMessageDispose = {
+            dispose: () => {
+                if (showHandle) {
+                    clearTimeout(showHandle);
+                }
+                if (hideHandle) {
+                    clearTimeout(hideHandle);
+                }
+                statusMessageEntry?.dispose();
+            }
+        };
+        if (hideAfter > 0) {
+            hideHandle = setTimeout(() => statusMessageDispose.dispose(), hideAfter);
+        }
+        this.currentStatusMessage = [item, statusMessageDispose];
+    }
+};
+NotificationsStatus = ( __decorate([
+    ( __param(1, IStatusbarService)),
+    ( __param(2, INotificationService))
+], NotificationsStatus));
+export { NotificationsStatus };