@codingame/monaco-vscode-extensions-service-override/vscode/src/vs/workbench/api/browser/mainThreadMessageService.js

VSCode public API plugged on the monaco editor - extensions service-override

import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
import { localize } from 'vscode/vscode/vs/nls';
import { toAction } from 'vscode/vscode/vs/base/common/actions';
import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
import { Event } from 'vscode/vscode/vs/base/common/event';
import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';

let MainThreadMessageService = class MainThreadMessageService {
    constructor(extHostContext, _notificationService, _commandService, _dialogService, extensionService) {
        this._notificationService = _notificationService;
        this._commandService = _commandService;
        this._dialogService = _dialogService;
        this.extensionsListener = extensionService.onDidChangeExtensions(e => {
            for (const extension of e.removed) {
                this._notificationService.removeFilter(extension.identifier.value);
            }
        });
    }
    dispose() {
        this.extensionsListener.dispose();
    }
    $showMessage(severity, message, options, commands) {
        if (options.modal) {
            return this._showModalMessage(severity, message, options.detail, commands, options.useCustom);
        }
        else {
            return this._showMessage(severity, message, commands, options);
        }
    }
    _showMessage(severity, message, commands, options) {
        return (
             (new Promise(resolve => {
                const primaryActions = ( (commands.map(command => toAction({
                    id: `_extension_message_handle_${command.handle}`,
                    label: command.title,
                    enabled: true,
                    run: () => {
                        resolve(command.handle);
                        return Promise.resolve();
                    }
                }))));
                let source;
                if (options.source) {
                    source = {
                        label: options.source.label,
                        id: options.source.identifier.value
                    };
                }
                if (!source) {
                    source = ( localize(4859, "Extension"));
                }
                const secondaryActions = [];
                if (options.source) {
                    secondaryActions.push(toAction({
                        id: options.source.identifier.value,
                        label: ( localize(4860, "Manage Extension")),
                        run: () => {
                            return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
                        }
                    }));
                }
                const messageHandle = this._notificationService.notify({
                    severity,
                    message,
                    actions: { primary: primaryActions, secondary: secondaryActions },
                    source
                });
                Event.once(messageHandle.onDidClose)(() => {
                    resolve(undefined);
                });
            }))
        );
    }
    async _showModalMessage(severity, message, detail, commands, useCustom) {
        const buttons = [];
        let cancelButton = undefined;
        for (const command of commands) {
            const button = {
                label: command.title,
                run: () => command.handle
            };
            if (command.isCloseAffordance) {
                cancelButton = button;
            }
            else {
                buttons.push(button);
            }
        }
        if (!cancelButton) {
            if (buttons.length > 0) {
                cancelButton = {
                    label: ( localize(4861, "Cancel")),
                    run: () => undefined
                };
            }
            else {
                cancelButton = {
                    label: ( localize(4862, "&&OK")),
                    run: () => undefined
                };
            }
        }
        const { result } = await this._dialogService.prompt({
            type: severity,
            message,
            detail,
            buttons,
            cancelButton,
            custom: useCustom
        });
        return result;
    }
};
MainThreadMessageService = __decorate([
    extHostNamedCustomer(MainContext.MainThreadMessageService),
    ( (__param(1, INotificationService))),
    ( (__param(2, ICommandService))),
    ( (__param(3, IDialogService))),
    ( (__param(4, IExtensionService)))
], MainThreadMessageService);

export { MainThreadMessageService };