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

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

@@ -0,0 +1,392 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { addDisposableListener, EventType, EventHelper, clearNode, $, isEventLike } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ButtonBar } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DisposableStore, dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ChoiceAction, NotificationViewItem } from '../../../common/notifications.js';
+import { ConfigureNotificationAction, ClearNotificationAction, ExpandNotificationAction, CollapseNotificationAction } from './notificationsActions.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { defaultProgressBarStyles, defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+class NotificationsListDelegate {
+    constructor(container) {
+        this.offsetHelper = this.createOffsetHelper(container);
+    }
+    createOffsetHelper(container) {
+        const offsetHelper = document.createElement('div');
+        offsetHelper.classList.add('notification-offset-helper');
+        container.appendChild(offsetHelper);
+        return offsetHelper;
+    }
+    getHeight(notification) {
+        if (!notification.expanded) {
+            return NotificationsListDelegate.ROW_HEIGHT;
+        }
+        let expandedHeight = NotificationsListDelegate.ROW_HEIGHT;
+        const preferredMessageHeight = this.computePreferredHeight(notification);
+        const messageOverflows = NotificationsListDelegate.LINE_HEIGHT < preferredMessageHeight;
+        if (messageOverflows) {
+            const overflow = preferredMessageHeight - NotificationsListDelegate.LINE_HEIGHT;
+            expandedHeight += overflow;
+        }
+        if (notification.source || isNonEmptyArray(notification.actions && notification.actions.primary)) {
+            expandedHeight += NotificationsListDelegate.ROW_HEIGHT;
+        }
+        if (expandedHeight === NotificationsListDelegate.ROW_HEIGHT) {
+            notification.collapse(true );
+        }
+        return expandedHeight;
+    }
+    computePreferredHeight(notification) {
+        let actions = 1;
+        if (notification.canCollapse) {
+            actions++;
+        }
+        if (isNonEmptyArray(notification.actions && notification.actions.secondary)) {
+            actions++;
+        }
+        this.offsetHelper.style.width = `${450  - ((10  + 26  + (actions * (24 + 8))  - 4) )}px`;
+        const renderedMessage = NotificationMessageRenderer.render(notification.message);
+        this.offsetHelper.appendChild(renderedMessage);
+        const preferredHeight = Math.max(this.offsetHelper.offsetHeight, this.offsetHelper.scrollHeight);
+        clearNode(this.offsetHelper);
+        return preferredHeight;
+    }
+    getTemplateId(element) {
+        if (element instanceof NotificationViewItem) {
+            return NotificationRenderer.TEMPLATE_ID;
+        }
+        throw new Error('unknown element type: ' + element);
+    }
+}
+NotificationsListDelegate.ROW_HEIGHT = 42;
+NotificationsListDelegate.LINE_HEIGHT = 22;
+class NotificationMessageRenderer {
+    static render(message, actionHandler) {
+        const messageContainer = document.createElement('span');
+        for (const node of message.linkedText.nodes) {
+            if (typeof node === 'string') {
+                messageContainer.appendChild(document.createTextNode(node));
+            }
+            else {
+                let title = node.title;
+                if (!title && node.href.startsWith('command:')) {
+                    title = ( localize(
+                        'executeCommand',
+                        "Click to execute command '{0}'",
+                        node.href.substr('command:'.length)
+                    ));
+                }
+                else if (!title) {
+                    title = node.href;
+                }
+                const anchor = $('a', { href: node.href, title, tabIndex: 0 }, node.label);
+                if (actionHandler) {
+                    const handleOpen = (e) => {
+                        if (isEventLike(e)) {
+                            EventHelper.stop(e, true);
+                        }
+                        actionHandler.callback(node.href);
+                    };
+                    const onClick = actionHandler.toDispose.add(( new DomEmitter(anchor, EventType.CLICK))).event;
+                    const onKeydown = actionHandler.toDispose.add(( new DomEmitter(anchor, EventType.KEY_DOWN))).event;
+                    const onSpaceOrEnter = actionHandler.toDispose.add(Event.chain(onKeydown)).filter(e => {
+                        const event = ( new StandardKeyboardEvent(e));
+                        return event.equals(10 ) || event.equals(3 );
+                    }).event;
+                    actionHandler.toDispose.add(Gesture.addTarget(anchor));
+                    const onTap = actionHandler.toDispose.add(( new DomEmitter(anchor, EventType$1.Tap))).event;
+                    Event.any(onClick, onTap, onSpaceOrEnter)(handleOpen, null, actionHandler.toDispose);
+                }
+                messageContainer.appendChild(anchor);
+            }
+        }
+        return messageContainer;
+    }
+}
+let NotificationRenderer = class NotificationRenderer {
+    constructor(actionRunner, contextMenuService, instantiationService) {
+        this.actionRunner = actionRunner;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+    }
+    get templateId() {
+        return NotificationRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = ( new DisposableStore());
+        data.container = document.createElement('div');
+        data.container.classList.add('notification-list-item');
+        data.mainRow = document.createElement('div');
+        data.mainRow.classList.add('notification-list-item-main-row');
+        data.icon = document.createElement('div');
+        data.icon.classList.add('notification-list-item-icon', 'codicon');
+        data.message = document.createElement('div');
+        data.message.classList.add('notification-list-item-message');
+        const toolbarContainer = document.createElement('div');
+        toolbarContainer.classList.add('notification-list-item-toolbar-container');
+        data.toolbar = ( new ActionBar(toolbarContainer, {
+            ariaLabel: ( localize('notificationActions', "Notification Actions")),
+            actionViewItemProvider: action => {
+                if (action && action instanceof ConfigureNotificationAction) {
+                    const item = ( new DropdownMenuActionViewItem(
+                        action,
+                        action.configurationActions,
+                        this.contextMenuService,
+                        { actionRunner: this.actionRunner, classNames: action.class }
+                    ));
+                    data.toDispose.add(item);
+                    return item;
+                }
+                return undefined;
+            },
+            actionRunner: this.actionRunner
+        }));
+        data.toDispose.add(data.toolbar);
+        data.detailsRow = document.createElement('div');
+        data.detailsRow.classList.add('notification-list-item-details-row');
+        data.source = document.createElement('div');
+        data.source.classList.add('notification-list-item-source');
+        data.buttonsContainer = document.createElement('div');
+        data.buttonsContainer.classList.add('notification-list-item-buttons-container');
+        container.appendChild(data.container);
+        data.container.appendChild(data.detailsRow);
+        data.detailsRow.appendChild(data.source);
+        data.detailsRow.appendChild(data.buttonsContainer);
+        data.container.appendChild(data.mainRow);
+        data.mainRow.appendChild(data.icon);
+        data.mainRow.appendChild(data.message);
+        data.mainRow.appendChild(toolbarContainer);
+        data.progress = ( new ProgressBar(container, defaultProgressBarStyles));
+        data.toDispose.add(data.progress);
+        data.renderer = this.instantiationService.createInstance(NotificationTemplateRenderer, data, this.actionRunner);
+        data.toDispose.add(data.renderer);
+        return data;
+    }
+    renderElement(notification, index, data) {
+        data.renderer.setInput(notification);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+NotificationRenderer.TEMPLATE_ID = 'notification';
+NotificationRenderer = ( __decorate([
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IInstantiationService))
+], NotificationRenderer));
+let NotificationTemplateRenderer = class NotificationTemplateRenderer extends Disposable {
+    constructor(template, actionRunner, openerService, instantiationService, keybindingService, contextMenuService) {
+        super();
+        this.template = template;
+        this.actionRunner = actionRunner;
+        this.openerService = openerService;
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.contextMenuService = contextMenuService;
+        this.inputDisposables = this._register(( new DisposableStore()));
+        if (!NotificationTemplateRenderer.closeNotificationAction) {
+            NotificationTemplateRenderer.closeNotificationAction = instantiationService.createInstance(ClearNotificationAction, ClearNotificationAction.ID, ClearNotificationAction.LABEL);
+            NotificationTemplateRenderer.expandNotificationAction = instantiationService.createInstance(ExpandNotificationAction, ExpandNotificationAction.ID, ExpandNotificationAction.LABEL);
+            NotificationTemplateRenderer.collapseNotificationAction = instantiationService.createInstance(CollapseNotificationAction, CollapseNotificationAction.ID, CollapseNotificationAction.LABEL);
+        }
+    }
+    setInput(notification) {
+        this.inputDisposables.clear();
+        this.render(notification);
+    }
+    render(notification) {
+        this.template.container.classList.toggle('expanded', notification.expanded);
+        this.inputDisposables.add(addDisposableListener(this.template.container, EventType.MOUSE_UP, e => {
+            if (e.button === 1 ) {
+                EventHelper.stop(e, true);
+            }
+        }));
+        this.inputDisposables.add(addDisposableListener(this.template.container, EventType.AUXCLICK, e => {
+            if (!notification.hasProgress && e.button === 1 ) {
+                EventHelper.stop(e, true);
+                notification.close();
+            }
+        }));
+        this.renderSeverity(notification);
+        const messageOverflows = this.renderMessage(notification);
+        this.renderSecondaryActions(notification, messageOverflows);
+        this.renderSource(notification);
+        this.renderButtons(notification);
+        this.renderProgress(notification);
+        this.inputDisposables.add(notification.onDidChangeContent(event => {
+            switch (event.kind) {
+                case 0 :
+                    this.renderSeverity(notification);
+                    break;
+                case 3 :
+                    this.renderProgress(notification);
+                    break;
+                case 1 :
+                    this.renderMessage(notification);
+                    break;
+            }
+        }));
+    }
+    renderSeverity(notification) {
+        NotificationTemplateRenderer.SEVERITIES.forEach(severity => {
+            if (notification.severity !== severity) {
+                this.template.icon.classList.remove(...ThemeIcon.asClassNameArray(this.toSeverityIcon(severity)));
+            }
+        });
+        this.template.icon.classList.add(...ThemeIcon.asClassNameArray(this.toSeverityIcon(notification.severity)));
+    }
+    renderMessage(notification) {
+        clearNode(this.template.message);
+        this.template.message.appendChild(NotificationMessageRenderer.render(notification.message, {
+            callback: link => this.openerService.open(( URI.parse(link)), { allowCommands: true }),
+            toDispose: this.inputDisposables
+        }));
+        const messageOverflows = notification.canCollapse && !notification.expanded && this.template.message.scrollWidth > this.template.message.clientWidth;
+        if (messageOverflows) {
+            this.template.message.title = this.template.message.textContent + '';
+        }
+        else {
+            this.template.message.removeAttribute('title');
+        }
+        return messageOverflows;
+    }
+    renderSecondaryActions(notification, messageOverflows) {
+        const actions = [];
+        const secondaryActions = notification.actions ? notification.actions.secondary : undefined;
+        if (isNonEmptyArray(secondaryActions)) {
+            const configureNotificationAction = this.instantiationService.createInstance(ConfigureNotificationAction, ConfigureNotificationAction.ID, ConfigureNotificationAction.LABEL, secondaryActions);
+            actions.push(configureNotificationAction);
+            this.inputDisposables.add(configureNotificationAction);
+        }
+        let showExpandCollapseAction = false;
+        if (notification.canCollapse) {
+            if (notification.expanded) {
+                showExpandCollapseAction = true;
+            }
+            else if (notification.source) {
+                showExpandCollapseAction = true;
+            }
+            else if (messageOverflows) {
+                showExpandCollapseAction = true;
+            }
+        }
+        if (showExpandCollapseAction) {
+            actions.push(notification.expanded ? NotificationTemplateRenderer.collapseNotificationAction : NotificationTemplateRenderer.expandNotificationAction);
+        }
+        if (!notification.hasProgress) {
+            actions.push(NotificationTemplateRenderer.closeNotificationAction);
+        }
+        this.template.toolbar.clear();
+        this.template.toolbar.context = notification;
+        actions.forEach(action => this.template.toolbar.push(action, { icon: true, label: false, keybinding: this.getKeybindingLabel(action) }));
+    }
+    renderSource(notification) {
+        if (notification.expanded && notification.source) {
+            this.template.source.textContent = ( localize('notificationSource', "Source: {0}", notification.source));
+            this.template.source.title = notification.source;
+        }
+        else {
+            this.template.source.textContent = '';
+            this.template.source.removeAttribute('title');
+        }
+    }
+    renderButtons(notification) {
+        clearNode(this.template.buttonsContainer);
+        const primaryActions = notification.actions ? notification.actions.primary : undefined;
+        if (notification.expanded && isNonEmptyArray(primaryActions)) {
+            const that = this;
+            const actionRunner = new (class extends ActionRunner {
+                async runAction(action) {
+                    that.actionRunner.run(action, notification);
+                    if (!(action instanceof ChoiceAction) || !action.keepOpen) {
+                        notification.close();
+                    }
+                }
+            })();
+            const buttonToolbar = this.inputDisposables.add(( new ButtonBar(this.template.buttonsContainer)));
+            for (let i = 0; i < primaryActions.length; i++) {
+                const action = primaryActions[i];
+                const options = {
+                    title: true,
+                    secondary: i > 0,
+                    ...defaultButtonStyles
+                };
+                const dropdownActions = action instanceof ChoiceAction ? action.menu : undefined;
+                const button = this.inputDisposables.add(dropdownActions ?
+                    buttonToolbar.addButtonWithDropdown({
+                        ...options,
+                        contextMenuProvider: this.contextMenuService,
+                        actions: dropdownActions,
+                        actionRunner
+                    }) :
+                    buttonToolbar.addButton(options));
+                button.label = action.label;
+                this.inputDisposables.add(button.onDidClick(e => {
+                    if (e) {
+                        EventHelper.stop(e, true);
+                    }
+                    actionRunner.run(action);
+                }));
+            }
+        }
+    }
+    renderProgress(notification) {
+        if (!notification.hasProgress) {
+            this.template.progress.stop().hide();
+            return;
+        }
+        const state = notification.progress.state;
+        if (state.infinite) {
+            this.template.progress.infinite().show();
+        }
+        else if (typeof state.total === 'number' || typeof state.worked === 'number') {
+            if (typeof state.total === 'number' && !this.template.progress.hasTotal()) {
+                this.template.progress.total(state.total);
+            }
+            if (typeof state.worked === 'number') {
+                this.template.progress.setWorked(state.worked).show();
+            }
+        }
+        else {
+            this.template.progress.done().hide();
+        }
+    }
+    toSeverityIcon(severity) {
+        switch (severity) {
+            case Severity.Warning:
+                return Codicon.warning;
+            case Severity.Error:
+                return Codicon.error;
+        }
+        return Codicon.info;
+    }
+    getKeybindingLabel(action) {
+        const keybinding = this.keybindingService.lookupKeybinding(action.id);
+        return keybinding ? keybinding.getLabel() : null;
+    }
+};
+NotificationTemplateRenderer.SEVERITIES = [Severity.Info, Severity.Warning, Severity.Error];
+NotificationTemplateRenderer = ( __decorate([
+    ( __param(2, IOpenerService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IContextMenuService))
+], NotificationTemplateRenderer));
+export { NotificationRenderer, NotificationTemplateRenderer, NotificationsListDelegate };