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

package/dist/vscode/vs/workbench/common/notifications.js

@@ -0,0 +1,448 @@
+import { NoOpNotification, NotificationsFilter, Severity, NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isErrorWithActions, toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+class NotificationHandle extends Disposable {
+    constructor(item, onClose) {
+        super();
+        this.item = item;
+        this.onClose = onClose;
+        this._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.item.onDidChangeVisibility(visible => this._onDidChangeVisibility.fire(visible)));
+        Event.once(this.item.onDidClose)(() => {
+            this._onDidClose.fire();
+            this.dispose();
+        });
+    }
+    get progress() {
+        return this.item.progress;
+    }
+    updateSeverity(severity) {
+        this.item.updateSeverity(severity);
+    }
+    updateMessage(message) {
+        this.item.updateMessage(message);
+    }
+    updateActions(actions) {
+        this.item.updateActions(actions);
+    }
+    close() {
+        this.onClose(this.item);
+        this.dispose();
+    }
+}
+class NotificationsModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeNotification = this._register(( new Emitter()));
+        this.onDidChangeNotification = this._onDidChangeNotification.event;
+        this._onDidChangeStatusMessage = this._register(( new Emitter()));
+        this.onDidChangeStatusMessage = this._onDidChangeStatusMessage.event;
+        this._onDidChangeFilter = this._register(( new Emitter()));
+        this.onDidChangeFilter = this._onDidChangeFilter.event;
+        this._notifications = [];
+        this.filter = NotificationsFilter.OFF;
+    }
+    get notifications() { return this._notifications; }
+    get statusMessage() { return this._statusMessage; }
+    setFilter(filter) {
+        this.filter = filter;
+        this._onDidChangeFilter.fire(filter);
+    }
+    addNotification(notification) {
+        const item = this.createViewItem(notification);
+        if (!item) {
+            return NotificationsModel.NO_OP_NOTIFICATION;
+        }
+        const duplicate = this.findNotification(item);
+        duplicate?.close();
+        this._notifications.splice(0, 0, item);
+        this._onDidChangeNotification.fire({ item, index: 0, kind: 0  });
+        return ( new NotificationHandle(item, item => this.onClose(item)));
+    }
+    onClose(item) {
+        const liveItem = this.findNotification(item);
+        if (liveItem && liveItem !== item) {
+            liveItem.close();
+        }
+        else {
+            item.close();
+        }
+    }
+    findNotification(item) {
+        return this._notifications.find(notification => notification.equals(item));
+    }
+    createViewItem(notification) {
+        const item = NotificationViewItem.create(notification, this.filter);
+        if (!item) {
+            return undefined;
+        }
+        const fireNotificationChangeEvent = (kind, detail) => {
+            const index = this._notifications.indexOf(item);
+            if (index >= 0) {
+                this._onDidChangeNotification.fire({ item, index, kind, detail });
+            }
+        };
+        const itemExpansionChangeListener = item.onDidChangeExpansion(() => fireNotificationChangeEvent(2 ));
+        const itemContentChangeListener = item.onDidChangeContent(e => fireNotificationChangeEvent(1 , e.kind));
+        Event.once(item.onDidClose)(() => {
+            itemExpansionChangeListener.dispose();
+            itemContentChangeListener.dispose();
+            const index = this._notifications.indexOf(item);
+            if (index >= 0) {
+                this._notifications.splice(index, 1);
+                this._onDidChangeNotification.fire({ item, index, kind: 3  });
+            }
+        });
+        return item;
+    }
+    showStatusMessage(message, options) {
+        const item = StatusMessageViewItem.create(message, options);
+        if (!item) {
+            return Disposable.None;
+        }
+        this._statusMessage = item;
+        this._onDidChangeStatusMessage.fire({ kind: 0 , item });
+        return toDisposable(() => {
+            if (this._statusMessage === item) {
+                this._statusMessage = undefined;
+                this._onDidChangeStatusMessage.fire({ kind: 1 , item });
+            }
+        });
+    }
+}
+NotificationsModel.NO_OP_NOTIFICATION = ( new NoOpNotification());
+function isNotificationViewItem(obj) {
+    return obj instanceof NotificationViewItem;
+}
+class NotificationViewItemProgress extends Disposable {
+    constructor() {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._state = Object.create(null);
+    }
+    get state() {
+        return this._state;
+    }
+    infinite() {
+        if (this._state.infinite) {
+            return;
+        }
+        this._state.infinite = true;
+        this._state.total = undefined;
+        this._state.worked = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+    done() {
+        if (this._state.done) {
+            return;
+        }
+        this._state.done = true;
+        this._state.infinite = undefined;
+        this._state.total = undefined;
+        this._state.worked = undefined;
+        this._onDidChange.fire();
+    }
+    total(value) {
+        if (this._state.total === value) {
+            return;
+        }
+        this._state.total = value;
+        this._state.infinite = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+    worked(value) {
+        if (typeof this._state.worked === 'number') {
+            this._state.worked += value;
+        }
+        else {
+            this._state.worked = value;
+        }
+        this._state.infinite = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+}
+class NotificationViewItem extends Disposable {
+    static create(notification, filter = NotificationsFilter.OFF) {
+        if (!notification || !notification.message || isCancellationError(notification.message)) {
+            return undefined;
+        }
+        let severity;
+        if (typeof notification.severity === 'number') {
+            severity = notification.severity;
+        }
+        else {
+            severity = Severity.Info;
+        }
+        const message = NotificationViewItem.parseNotificationMessage(notification.message);
+        if (!message) {
+            return undefined;
+        }
+        let actions;
+        if (notification.actions) {
+            actions = notification.actions;
+        }
+        else if (isErrorWithActions(notification.message)) {
+            actions = { primary: notification.message.actions };
+        }
+        let priority = notification.priority ?? NotificationPriority.DEFAULT;
+        if (priority === NotificationPriority.DEFAULT && (filter === NotificationsFilter.SILENT || (filter === NotificationsFilter.ERROR && notification.severity !== Severity.Error))) {
+            priority = NotificationPriority.SILENT;
+        }
+        return ( new NotificationViewItem(
+            notification.id,
+            severity,
+            notification.sticky,
+            priority,
+            message,
+            notification.source,
+            notification.progress,
+            actions
+        ));
+    }
+    static parseNotificationMessage(input) {
+        let message;
+        if (input instanceof Error) {
+            message = toErrorMessage(input, false);
+        }
+        else if (typeof input === 'string') {
+            message = input;
+        }
+        if (!message) {
+            return undefined;
+        }
+        const raw = message;
+        if (message.length > NotificationViewItem.MAX_MESSAGE_LENGTH) {
+            message = `${message.substr(0, NotificationViewItem.MAX_MESSAGE_LENGTH)}...`;
+        }
+        message = message.replace(/(\r\n|\n|\r)/gm, ' ').trim();
+        const linkedText = parseLinkedText(message);
+        return { raw, linkedText, original: input };
+    }
+    constructor(id, _severity, _sticky, _priority, _message, _source, progress, actions) {
+        super();
+        this.id = id;
+        this._severity = _severity;
+        this._sticky = _sticky;
+        this._priority = _priority;
+        this._message = _message;
+        this._source = _source;
+        this._visible = false;
+        this._onDidChangeExpansion = this._register(( new Emitter()));
+        this.onDidChangeExpansion = this._onDidChangeExpansion.event;
+        this._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        if (progress) {
+            this.setProgress(progress);
+        }
+        this.setActions(actions);
+    }
+    setProgress(progress) {
+        if (progress.infinite) {
+            this.progress.infinite();
+        }
+        else if (progress.total) {
+            this.progress.total(progress.total);
+            if (progress.worked) {
+                this.progress.worked(progress.worked);
+            }
+        }
+    }
+    setActions(actions = { primary: [], secondary: [] }) {
+        this._actions = {
+            primary: Array.isArray(actions.primary) ? actions.primary : [],
+            secondary: Array.isArray(actions.secondary) ? actions.secondary : []
+        };
+        this._expanded = actions.primary && actions.primary.length > 0;
+    }
+    get canCollapse() {
+        return !this.hasActions;
+    }
+    get expanded() {
+        return !!this._expanded;
+    }
+    get severity() {
+        return this._severity;
+    }
+    get sticky() {
+        if (this._sticky) {
+            return true;
+        }
+        const hasActions = this.hasActions;
+        if ((hasActions && this._severity === Severity.Error) ||
+            (!hasActions && this._expanded) ||
+            (this._progress && !this._progress.state.done)
+        ) {
+            return true;
+        }
+        return false;
+    }
+    get priority() {
+        return this._priority;
+    }
+    get hasActions() {
+        if (!this._actions) {
+            return false;
+        }
+        if (!this._actions.primary) {
+            return false;
+        }
+        return this._actions.primary.length > 0;
+    }
+    get hasProgress() {
+        return !!this._progress;
+    }
+    get progress() {
+        if (!this._progress) {
+            this._progress = this._register(( new NotificationViewItemProgress()));
+            this._register(this._progress.onDidChange(() => this._onDidChangeContent.fire({ kind: 3  })));
+        }
+        return this._progress;
+    }
+    get message() {
+        return this._message;
+    }
+    get source() {
+        return typeof this._source === 'string' ? this._source : (this._source ? this._source.label : undefined);
+    }
+    get sourceId() {
+        return (this._source && typeof this._source !== 'string' && 'id' in this._source) ? this._source.id : undefined;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get visible() {
+        return this._visible;
+    }
+    updateSeverity(severity) {
+        if (severity === this._severity) {
+            return;
+        }
+        this._severity = severity;
+        this._onDidChangeContent.fire({ kind: 0  });
+    }
+    updateMessage(input) {
+        const message = NotificationViewItem.parseNotificationMessage(input);
+        if (!message || message.raw === this._message.raw) {
+            return;
+        }
+        this._message = message;
+        this._onDidChangeContent.fire({ kind: 1  });
+    }
+    updateActions(actions) {
+        this.setActions(actions);
+        this._onDidChangeContent.fire({ kind: 2  });
+    }
+    updateVisibility(visible) {
+        if (this._visible !== visible) {
+            this._visible = visible;
+            this._onDidChangeVisibility.fire(visible);
+        }
+    }
+    expand() {
+        if (this._expanded || !this.canCollapse) {
+            return;
+        }
+        this._expanded = true;
+        this._onDidChangeExpansion.fire();
+    }
+    collapse(skipEvents) {
+        if (!this._expanded || !this.canCollapse) {
+            return;
+        }
+        this._expanded = false;
+        if (!skipEvents) {
+            this._onDidChangeExpansion.fire();
+        }
+    }
+    toggle() {
+        if (this._expanded) {
+            this.collapse();
+        }
+        else {
+            this.expand();
+        }
+    }
+    close() {
+        this._onDidClose.fire();
+        this.dispose();
+    }
+    equals(other) {
+        if (this.hasProgress || other.hasProgress) {
+            return false;
+        }
+        if (typeof this.id === 'string' || typeof other.id === 'string') {
+            return this.id === other.id;
+        }
+        if (typeof this._source === 'object') {
+            if (this._source.label !== other.source || this._source.id !== other.sourceId) {
+                return false;
+            }
+        }
+        else if (this._source !== other.source) {
+            return false;
+        }
+        if (this._message.raw !== other.message.raw) {
+            return false;
+        }
+        const primaryActions = (this._actions && this._actions.primary) || [];
+        const otherPrimaryActions = (other.actions && other.actions.primary) || [];
+        return equals(primaryActions, otherPrimaryActions, (action, otherAction) => (action.id + action.label) === (otherAction.id + otherAction.label));
+    }
+}
+NotificationViewItem.MAX_MESSAGE_LENGTH = 1000;
+class ChoiceAction extends Action {
+    constructor(id, choice) {
+        super(id, choice.label, undefined, true, async () => {
+            choice.run();
+            this._onDidRun.fire();
+        });
+        this._onDidRun = this._register(( new Emitter()));
+        this.onDidRun = this._onDidRun.event;
+        this._keepOpen = !!choice.keepOpen;
+        this._menu = !choice.isSecondary && choice.menu ? ( choice.menu.map((c, index) => ( new ChoiceAction(`${id}.${index}`, c)))) : undefined;
+    }
+    get menu() {
+        return this._menu;
+    }
+    get keepOpen() {
+        return this._keepOpen;
+    }
+}
+class StatusMessageViewItem {
+    static create(notification, options) {
+        if (!notification || isCancellationError(notification)) {
+            return undefined;
+        }
+        let message;
+        if (notification instanceof Error) {
+            message = toErrorMessage(notification, false);
+        }
+        else if (typeof notification === 'string') {
+            message = notification;
+        }
+        if (!message) {
+            return undefined;
+        }
+        return { message, options };
+    }
+}
+export { ChoiceAction, NotificationHandle, NotificationViewItem, NotificationViewItemProgress, NotificationsModel, isNotificationViewItem };

package/dist/vscode/vs/workbench/common/resources.js

@@ -0,0 +1,86 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+let ResourceGlobMatcher = class ResourceGlobMatcher extends Disposable {
+    constructor(globFn, shouldUpdate, contextService, configurationService) {
+        super();
+        this.globFn = globFn;
+        this.shouldUpdate = shouldUpdate;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this._onExpressionChange = this._register(( new Emitter()));
+        this.onExpressionChange = this._onExpressionChange.event;
+        this.mapRootToParsedExpression = ( new Map());
+        this.mapRootToExpressionConfig = ( new Map());
+        this.updateExcludes(false);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (this.shouldUpdate(e)) {
+                this.updateExcludes(true);
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExcludes(true)));
+    }
+    updateExcludes(fromEvent) {
+        let changed = false;
+        this.contextService.getWorkspace().folders.forEach(folder => {
+            const rootExcludes = this.globFn(folder.uri);
+            if (!this.mapRootToExpressionConfig.has(( folder.uri.toString())) || !equals(this.mapRootToExpressionConfig.get(( folder.uri.toString())), rootExcludes)) {
+                changed = true;
+                this.mapRootToParsedExpression.set(( folder.uri.toString()), parse(rootExcludes));
+                this.mapRootToExpressionConfig.set(( folder.uri.toString()), deepClone(rootExcludes));
+            }
+        });
+        this.mapRootToExpressionConfig.forEach((value, root) => {
+            if (root === ResourceGlobMatcher.NO_ROOT) {
+                return;
+            }
+            if (root && !this.contextService.getWorkspaceFolder(( URI.parse(root)))) {
+                this.mapRootToParsedExpression.delete(root);
+                this.mapRootToExpressionConfig.delete(root);
+                changed = true;
+            }
+        });
+        const globalExcludes = this.globFn();
+        if (!this.mapRootToExpressionConfig.has(ResourceGlobMatcher.NO_ROOT) || !equals(this.mapRootToExpressionConfig.get(ResourceGlobMatcher.NO_ROOT), globalExcludes)) {
+            changed = true;
+            this.mapRootToParsedExpression.set(ResourceGlobMatcher.NO_ROOT, parse(globalExcludes));
+            this.mapRootToExpressionConfig.set(ResourceGlobMatcher.NO_ROOT, deepClone(globalExcludes));
+        }
+        if (fromEvent && changed) {
+            this._onExpressionChange.fire();
+        }
+    }
+    matches(resource, hasSibling) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        let expressionForRoot;
+        if (folder && this.mapRootToParsedExpression.has(( folder.uri.toString()))) {
+            expressionForRoot = this.mapRootToParsedExpression.get(( folder.uri.toString()));
+        }
+        else {
+            expressionForRoot = this.mapRootToParsedExpression.get(ResourceGlobMatcher.NO_ROOT);
+        }
+        let resourcePathToMatch;
+        if (folder) {
+            resourcePathToMatch = relativePath(folder.uri, resource);
+        }
+        else {
+            resourcePathToMatch = resource.fsPath;
+        }
+        return !!expressionForRoot && typeof resourcePathToMatch === 'string' && !!expressionForRoot(resourcePathToMatch, undefined, hasSibling);
+    }
+};
+ResourceGlobMatcher.NO_ROOT = null;
+ResourceGlobMatcher = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IConfigurationService))
+], ResourceGlobMatcher));
+export { ResourceGlobMatcher };