@codingame/monaco-vscode-api 10.1.4 → 11.0.1

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

@@ -1,420 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { clearNode, $, EventType, addDisposableListener, EventHelper, isEventLike } from '../../../../base/browser/dom.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
-import { URI } from '../../../../base/common/uri.js';
-import { localize } from '../../../../nls.js';
-import { ButtonBar } from '../../../../base/browser/ui/button/button.js';
-import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
-import { toAction, Separator, ActionRunner } from '../../../../base/common/actions.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { DisposableStore, dispose, Disposable } from '../../../../base/common/lifecycle.js';
-import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
-import { NotificationViewItem, ChoiceAction } from '../../../common/notifications.js';
-import { ConfigureNotificationAction, ClearNotificationAction, ExpandNotificationAction, CollapseNotificationAction } from './notificationsActions.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
-import { ProgressBar } from '../../../../base/browser/ui/progressbar/progressbar.js';
-import { isNotificationSource, NotificationsFilter } from '../../../../platform/notification/common/notification.js';
-import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
-import { isNonEmptyArray } from '../../../../base/common/arrays.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { ThemeIcon } from '../../../../base/common/themables.js';
-import { DropdownMenuActionViewItem } from '../../../../base/browser/ui/dropdown/dropdownActionViewItem.js';
-import { DomEmitter } from '../../../../base/browser/event.js';
-import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
-import { Event } from '../../../../base/common/event.js';
-import { defaultProgressBarStyles, defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
-import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
-import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
-import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
-import Severity$1 from '../../../../base/common/severity.js';
-var NotificationRenderer_1, NotificationTemplateRenderer_1;
-class NotificationsListDelegate {
-    static { this.ROW_HEIGHT = 42; }
-    static { this.LINE_HEIGHT = 22; }
-    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 = 0;
-        if (!notification.hasProgress) {
-            actions++;
-        }
-        if (notification.canCollapse) {
-            actions++;
-        }
-        if (isNonEmptyArray(notification.actions && notification.actions.secondary)) {
-            actions++;
-        }
-        this.offsetHelper.style.width = `${450  - ((10  + 30  + (actions * 30)  - (Math.max(actions - 1, 0) * 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)));
-    }
-}
-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(
-                        10680,
-                        "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 = Event.chain(onKeydown, $ => $.filter(e => {
-                        const event = ( (new StandardKeyboardEvent(e)));
-                        return event.equals(10 ) || event.equals(3 );
-                    }));
-                    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 {
-    static { NotificationRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'notification'; }
-    constructor(actionRunner, contextMenuService, instantiationService, notificationService) {
-        this.actionRunner = actionRunner;
-        this.contextMenuService = contextMenuService;
-        this.instantiationService = instantiationService;
-        this.notificationService = notificationService;
-    }
-    get templateId() {
-        return NotificationRenderer_1.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 that = this;
-        const toolbarContainer = document.createElement('div');
-        toolbarContainer.classList.add('notification-list-item-toolbar-container');
-        data.toolbar = ( (new ActionBar(toolbarContainer, {
-            ariaLabel: ( localize(10681, "Notification Actions")),
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof ConfigureNotificationAction) {
-                    return data.toDispose.add(( (new DropdownMenuActionViewItem(action, {
-                        getActions() {
-                            const actions = [];
-                            const source = { id: action.notification.sourceId, label: action.notification.source };
-                            if (isNotificationSource(source)) {
-                                const isSourceFiltered = that.notificationService.getFilter(source) === NotificationsFilter.ERROR;
-                                actions.push(toAction({
-                                    id: source.id,
-                                    label: isSourceFiltered ? ( localize(10682, "Turn On All Notifications from '{0}'", source.label)) : ( localize(10683, "Turn Off Info and Warning Notifications from '{0}'", source.label)),
-                                    run: () => that.notificationService.setFilter({ ...source, filter: isSourceFiltered ? NotificationsFilter.OFF : NotificationsFilter.ERROR })
-                                }));
-                                if (action.notification.actions?.secondary?.length) {
-                                    actions.push(( (new Separator())));
-                                }
-                            }
-                            if (Array.isArray(action.notification.actions?.secondary)) {
-                                actions.push(...action.notification.actions.secondary);
-                            }
-                            return actions;
-                        },
-                    }, this.contextMenuService, {
-                        ...options,
-                        actionRunner: this.actionRunner,
-                        classNames: action.class
-                    }))));
-                }
-                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 = NotificationRenderer_1 = ( (__decorate([
-    ( (__param(1, IContextMenuService))),
-    ( (__param(2, IInstantiationService))),
-    ( (__param(3, INotificationService)))
-], NotificationRenderer)));
-let NotificationTemplateRenderer = class NotificationTemplateRenderer extends Disposable {
-    static { NotificationTemplateRenderer_1 = this; }
-    static { this.SEVERITIES = [Severity$1.Info, Severity$1.Warning, Severity$1.Error]; }
-    constructor(template, actionRunner, openerService, instantiationService, keybindingService, contextMenuService, hoverService) {
-        super();
-        this.template = template;
-        this.actionRunner = actionRunner;
-        this.openerService = openerService;
-        this.instantiationService = instantiationService;
-        this.keybindingService = keybindingService;
-        this.contextMenuService = contextMenuService;
-        this.hoverService = hoverService;
-        this.inputDisposables = this._register(( (new DisposableStore())));
-        if (!NotificationTemplateRenderer_1.closeNotificationAction) {
-            NotificationTemplateRenderer_1.closeNotificationAction = instantiationService.createInstance(ClearNotificationAction, ClearNotificationAction.ID, ClearNotificationAction.LABEL);
-            NotificationTemplateRenderer_1.expandNotificationAction = instantiationService.createInstance(ExpandNotificationAction, ExpandNotificationAction.ID, ExpandNotificationAction.LABEL);
-            NotificationTemplateRenderer_1.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 messageCustomHover = this.inputDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), this.template.message, ''));
-        const messageOverflows = this.renderMessage(notification, messageCustomHover);
-        this.renderSecondaryActions(notification, messageOverflows);
-        const sourceCustomHover = this.inputDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), this.template.source, ''));
-        this.renderSource(notification, sourceCustomHover);
-        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, messageCustomHover);
-                    break;
-            }
-        }));
-    }
-    renderSeverity(notification) {
-        NotificationTemplateRenderer_1.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, customHover) {
-        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;
-        customHover.update(messageOverflows ? this.template.message.textContent + '' : '');
-        return messageOverflows;
-    }
-    renderSecondaryActions(notification, messageOverflows) {
-        const actions = [];
-        if (isNonEmptyArray(notification.actions?.secondary)) {
-            const configureNotificationAction = this.instantiationService.createInstance(ConfigureNotificationAction, ConfigureNotificationAction.ID, ConfigureNotificationAction.LABEL, notification);
-            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_1.collapseNotificationAction : NotificationTemplateRenderer_1.expandNotificationAction);
-        }
-        if (!notification.hasProgress) {
-            actions.push(NotificationTemplateRenderer_1.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, sourceCustomHover) {
-        if (notification.expanded && notification.source) {
-            this.template.source.textContent = ( localize(10684, "Source: {0}", notification.source));
-            sourceCustomHover.update(notification.source);
-        }
-        else {
-            this.template.source.textContent = '';
-            sourceCustomHover.update('');
-        }
-    }
-    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$1.Warning:
-                return Codicon.warning;
-            case Severity$1.Error:
-                return Codicon.error;
-        }
-        return Codicon.info;
-    }
-    getKeybindingLabel(action) {
-        const keybinding = this.keybindingService.lookupKeybinding(action.id);
-        return keybinding ? keybinding.getLabel() : null;
-    }
-};
-NotificationTemplateRenderer = NotificationTemplateRenderer_1 = ( (__decorate([
-    ( (__param(2, IOpenerService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IKeybindingService))),
-    ( (__param(5, IContextMenuService))),
-    ( (__param(6, IHoverService)))
-], NotificationTemplateRenderer)));
-export { NotificationRenderer, NotificationTemplateRenderer, NotificationsListDelegate };

package/vscode/src/vs/workbench/browser/web.api.js

@@ -1,8 +0,0 @@
-var ColorScheme;
-( (function(ColorScheme) {
-    ColorScheme["DARK"] = "dark";
-    ColorScheme["LIGHT"] = "light";
-    ColorScheme["HIGH_CONTRAST_LIGHT"] = "hcLight";
-    ColorScheme["HIGH_CONTRAST_DARK"] = "hcDark";
-})(ColorScheme || (ColorScheme = {})));
-export { ColorScheme };

package/vscode/src/vs/workbench/common/editor/filteredEditorGroupModel.js

@@ -1,110 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-class FilteredEditorGroupModel extends Disposable {
-    constructor(model) {
-        super();
-        this.model = model;
-        this._onDidModelChange = this._register(( new Emitter()));
-        this.onDidModelChange = this._onDidModelChange.event;
-        this._register(this.model.onDidModelChange(e => {
-            const candidateOrIndex = e.editorIndex ?? e.editor;
-            if (candidateOrIndex !== undefined) {
-                if (!this.filter(candidateOrIndex)) {
-                    return;
-                }
-            }
-            this._onDidModelChange.fire(e);
-        }));
-    }
-    get id() { return this.model.id; }
-    get isLocked() { return this.model.isLocked; }
-    get stickyCount() { return this.model.stickyCount; }
-    get activeEditor() { return this.model.activeEditor && this.filter(this.model.activeEditor) ? this.model.activeEditor : null; }
-    get previewEditor() { return this.model.previewEditor && this.filter(this.model.previewEditor) ? this.model.previewEditor : null; }
-    get selectedEditors() { return this.model.selectedEditors.filter(e => this.filter(e)); }
-    isPinned(editorOrIndex) { return this.model.isPinned(editorOrIndex); }
-    isTransient(editorOrIndex) { return this.model.isTransient(editorOrIndex); }
-    isSticky(editorOrIndex) { return this.model.isSticky(editorOrIndex); }
-    isActive(editor) { return this.model.isActive(editor); }
-    isSelected(editorOrIndex) { return this.model.isSelected(editorOrIndex); }
-    isFirst(editor) {
-        return this.model.isFirst(editor, this.getEditors(1 ));
-    }
-    isLast(editor) {
-        return this.model.isLast(editor, this.getEditors(1 ));
-    }
-    getEditors(order, options) {
-        const editors = this.model.getEditors(order, options);
-        return editors.filter(e => this.filter(e));
-    }
-    findEditor(candidate, options) {
-        const result = this.model.findEditor(candidate, options);
-        if (!result) {
-            return undefined;
-        }
-        return this.filter(result[1]) ? result : undefined;
-    }
-}
-class StickyEditorGroupModel extends FilteredEditorGroupModel {
-    get count() { return this.model.stickyCount; }
-    getEditors(order, options) {
-        if (options?.excludeSticky) {
-            return [];
-        }
-        if (order === 1 ) {
-            return this.model.getEditors(1 ).slice(0, this.model.stickyCount);
-        }
-        return super.getEditors(order, options);
-    }
-    isSticky(editorOrIndex) {
-        return true;
-    }
-    getEditorByIndex(index) {
-        return index < this.count ? this.model.getEditorByIndex(index) : undefined;
-    }
-    indexOf(editor, editors, options) {
-        const editorIndex = this.model.indexOf(editor, editors, options);
-        if (editorIndex < 0 || editorIndex >= this.model.stickyCount) {
-            return -1;
-        }
-        return editorIndex;
-    }
-    contains(candidate, options) {
-        const editorIndex = this.model.indexOf(candidate, undefined, options);
-        return editorIndex >= 0 && editorIndex < this.model.stickyCount;
-    }
-    filter(candidateOrIndex) {
-        return this.model.isSticky(candidateOrIndex);
-    }
-}
-class UnstickyEditorGroupModel extends FilteredEditorGroupModel {
-    get count() { return this.model.count - this.model.stickyCount; }
-    get stickyCount() { return 0; }
-    isSticky(editorOrIndex) {
-        return false;
-    }
-    getEditors(order, options) {
-        if (order === 1 ) {
-            return this.model.getEditors(1 ).slice(this.model.stickyCount);
-        }
-        return super.getEditors(order, options);
-    }
-    getEditorByIndex(index) {
-        return index >= 0 ? this.model.getEditorByIndex(index + this.model.stickyCount) : undefined;
-    }
-    indexOf(editor, editors, options) {
-        const editorIndex = this.model.indexOf(editor, editors, options);
-        if (editorIndex < this.model.stickyCount || editorIndex >= this.model.count) {
-            return -1;
-        }
-        return editorIndex - this.model.stickyCount;
-    }
-    contains(candidate, options) {
-        const editorIndex = this.model.indexOf(candidate, undefined, options);
-        return editorIndex >= this.model.stickyCount && editorIndex < this.model.count;
-    }
-    filter(candidateOrIndex) {
-        return !this.model.isSticky(candidateOrIndex);
-    }
-}
-export { StickyEditorGroupModel, UnstickyEditorGroupModel };