@codingame/monaco-vscode-dialogs-service-override 1.82.4 → 1.82.5-next.1

package/dialogs.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(container?: HTMLElement): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/dialogs.js

@@ -0,0 +1,58 @@
+import './vscode/src/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js';
+import { DialogService } from './vscode/src/vs/workbench/services/dialogs/common/dialogService.js';
+import './override/vs/platform/dialogs/common/dialogs.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { AbstractFileDialogService } from './vscode/src/vs/workbench/services/dialogs/browser/abstractFileDialogService.js';
+import getServiceOverride$1 from 'vscode/service-override/layout';
+import { unsupported } from './tools.js';
+import { IDialogService, IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+class FileDialogService extends AbstractFileDialogService {
+    constructor() {
+        super(...arguments);
+        this.pickWorkspaceAndOpen = unsupported;
+    }
+    async pickFileFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        return super.pickFileFolderAndOpenSimplified(schema, options, false);
+    }
+    async pickFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFolderPath(schema);
+        }
+        return super.pickFolderAndOpenSimplified(schema, options);
+    }
+    async pickFileAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        return super.pickFileAndOpenSimplified(schema, options, false);
+    }
+    async showSaveDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        return super.showSaveDialogSimplified(schema, options);
+    }
+    async showOpenDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        return super.showOpenDialogSimplified(schema, options);
+    }
+    async pickFileToSave(defaultUri, availableFileSystems) {
+        const schema = this.getFileSystemSchema({ defaultUri, availableFileSystems });
+        const options = this.getPickFileToSaveDialogOptions(defaultUri, availableFileSystems);
+        return super.pickFileToSaveSimplified(schema, options);
+    }
+}
+function getServiceOverride(container) {
+    return {
+        [( IDialogService.toString())]: new SyncDescriptor(DialogService, undefined, true),
+        [( IFileDialogService.toString())]: new SyncDescriptor(FileDialogService, undefined, true),
+        ...getServiceOverride$1(container)
+    };
+}
+
+export { getServiceOverride as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -1 +1 @@
-export { default } from 'vscode/service-override/dialogs'
+export { default } from './dialogs.js';

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/dialogs'
+export { default } from './dialogs.js';

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-dialogs-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.1",
     "monaco-editor": "0.43.0"
   }
 }

package/tools.js

@@ -0,0 +1,5 @@
+function unsupported() {
+    throw new Error('unsupported');
+}
+
+export { unsupported };

package/vscode/src/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js

@@ -0,0 +1,71 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { BrowserDialogHandler } from './dialogHandler.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let DialogHandlerContribution = class DialogHandlerContribution extends Disposable {
+    constructor(dialogService, logService, layoutService, keybindingService, instantiationService, productService, clipboardService) {
+        super();
+        this.dialogService = dialogService;
+        this.impl = ( new BrowserDialogHandler(
+            logService,
+            layoutService,
+            keybindingService,
+            instantiationService,
+            productService,
+            clipboardService
+        ));
+        this.model = this.dialogService.model;
+        this._register(this.model.onWillShowDialog(() => {
+            if (!this.currentDialog) {
+                this.processDialogs();
+            }
+        }));
+        this.processDialogs();
+    }
+    async processDialogs() {
+        while (this.model.dialogs.length) {
+            this.currentDialog = this.model.dialogs[0];
+            let result = undefined;
+            if (this.currentDialog.args.confirmArgs) {
+                const args = this.currentDialog.args.confirmArgs;
+                result = await this.impl.confirm(args.confirmation);
+            }
+            else if (this.currentDialog.args.inputArgs) {
+                const args = this.currentDialog.args.inputArgs;
+                result = await this.impl.input(args.input);
+            }
+            else if (this.currentDialog.args.promptArgs) {
+                const args = this.currentDialog.args.promptArgs;
+                result = await this.impl.prompt(args.prompt);
+            }
+            else {
+                await this.impl.about();
+            }
+            this.currentDialog.close(result);
+            this.currentDialog = undefined;
+        }
+    }
+};
+DialogHandlerContribution = ( __decorate([
+    ( __param(0, IDialogService)),
+    ( __param(1, ILogService)),
+    ( __param(2, ILayoutService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IProductService)),
+    ( __param(6, IClipboardService))
+], DialogHandlerContribution));
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+workbenchRegistry.registerWorkbenchContribution(DialogHandlerContribution, 1 );
+
+export { DialogHandlerContribution };

package/vscode/src/vs/workbench/browser/parts/dialogs/dialogHandler.js

@@ -0,0 +1,129 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Dialog } from 'monaco-editor/esm/vs/base/browser/ui/dialog/dialog.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EventHelper } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { AbstractDialogHandler } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var BrowserDialogHandler_1;
+let BrowserDialogHandler = class BrowserDialogHandler extends AbstractDialogHandler {
+    static { BrowserDialogHandler_1 = this; }
+    static { this.ALLOWABLE_COMMANDS = [
+        'copy',
+        'cut',
+        'editor.action.selectAll',
+        'editor.action.clipboardCopyAction',
+        'editor.action.clipboardCutAction',
+        'editor.action.clipboardPasteAction'
+    ]; }
+    constructor(logService, layoutService, keybindingService, instantiationService, productService, clipboardService) {
+        super();
+        this.logService = logService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+        this.productService = productService;
+        this.clipboardService = clipboardService;
+        this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+    }
+    async prompt(prompt) {
+        this.logService.trace('DialogService#prompt', prompt.message);
+        const buttons = this.getPromptButtons(prompt);
+        const { button, checkboxChecked } = await this.doShow(prompt.type, prompt.message, buttons, prompt.detail, prompt.cancelButton ? buttons.length - 1 : -1 , prompt.checkbox, undefined, typeof prompt?.custom === 'object' ? prompt.custom : undefined);
+        return this.getPromptResult(prompt, button, checkboxChecked);
+    }
+    async confirm(confirmation) {
+        this.logService.trace('DialogService#confirm', confirmation.message);
+        const buttons = this.getConfirmationButtons(confirmation);
+        const { button, checkboxChecked } = await this.doShow(confirmation.type ?? 'question', confirmation.message, buttons, confirmation.detail, buttons.length - 1, confirmation.checkbox, undefined, typeof confirmation?.custom === 'object' ? confirmation.custom : undefined);
+        return { confirmed: button === 0, checkboxChecked };
+    }
+    async input(input) {
+        this.logService.trace('DialogService#input', input.message);
+        const buttons = this.getInputButtons(input);
+        const { button, checkboxChecked, values } = await this.doShow(input.type ?? 'question', input.message, buttons, input.detail, buttons.length - 1, input?.checkbox, input.inputs, typeof input.custom === 'object' ? input.custom : undefined);
+        return { confirmed: button === 0, checkboxChecked, values };
+    }
+    async about() {
+        const detailString = (useAgo) => {
+            return ( localize(
+                'aboutDetail',
+                "Version: {0}\nCommit: {1}\nDate: {2}\nBrowser: {3}",
+                this.productService.version || 'Unknown',
+                this.productService.commit || 'Unknown',
+                this.productService.date ? `${this.productService.date}${useAgo ? ' (' + fromNow(( new Date(this.productService.date)), true) + ')' : ''}` : 'Unknown',
+                navigator.userAgent
+            ));
+        };
+        const detail = detailString(true);
+        const detailToCopy = detailString(false);
+        const { button } = await this.doShow(Severity.Info, this.productService.nameLong, [
+            ( localize({ key: 'copy', comment: ['&& denotes a mnemonic'] }, "&&Copy")),
+            ( localize('ok', "OK"))
+        ], detail, 1);
+        if (button === 0) {
+            this.clipboardService.writeText(detailToCopy);
+        }
+    }
+    async doShow(type, message, buttons, detail, cancelId, checkbox, inputs, customOptions) {
+        const dialogDisposables = ( new DisposableStore());
+        const renderBody = customOptions ? (parent) => {
+            parent.classList.add(...(customOptions.classes || []));
+            customOptions.markdownDetails?.forEach(markdownDetail => {
+                const result = this.markdownRenderer.render(markdownDetail.markdown);
+                parent.appendChild(result.element);
+                result.element.classList.add(...(markdownDetail.classes || []));
+                dialogDisposables.add(result);
+            });
+        } : undefined;
+        const dialog = ( new Dialog(this.layoutService.container, message, buttons, {
+            detail,
+            cancelId,
+            type: this.getDialogType(type),
+            keyEventProcessor: (event) => {
+                const resolved = this.keybindingService.softDispatch(event, this.layoutService.container);
+                if (resolved.kind === 2  && resolved.commandId) {
+                    if (BrowserDialogHandler_1.ALLOWABLE_COMMANDS.indexOf(resolved.commandId) === -1) {
+                        EventHelper.stop(event, true);
+                    }
+                }
+            },
+            renderBody,
+            icon: customOptions?.icon,
+            disableCloseAction: customOptions?.disableCloseAction,
+            buttonDetails: customOptions?.buttonDetails,
+            checkboxLabel: checkbox?.label,
+            checkboxChecked: checkbox?.checked,
+            inputs,
+            buttonStyles: defaultButtonStyles,
+            checkboxStyles: defaultCheckboxStyles,
+            inputBoxStyles: defaultInputBoxStyles,
+            dialogStyles: defaultDialogStyles
+        }));
+        dialogDisposables.add(dialog);
+        const result = await dialog.show();
+        dialogDisposables.dispose();
+        return result;
+    }
+};
+BrowserDialogHandler = BrowserDialogHandler_1 = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, ILayoutService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IClipboardService))
+], BrowserDialogHandler));
+
+export { BrowserDialogHandler };

package/vscode/src/vs/workbench/common/dialogs.js

@@ -0,0 +1,33 @@
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class DialogsModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.dialogs = [];
+        this._onWillShowDialog = this._register(( new Emitter()));
+        this.onWillShowDialog = this._onWillShowDialog.event;
+        this._onDidShowDialog = this._register(( new Emitter()));
+        this.onDidShowDialog = this._onDidShowDialog.event;
+    }
+    show(dialog) {
+        const promise = ( new DeferredPromise());
+        const item = {
+            args: dialog,
+            close: result => {
+                this.dialogs.splice(0, 1);
+                promise.complete(result);
+                this._onDidShowDialog.fire();
+            }
+        };
+        this.dialogs.push(item);
+        this._onWillShowDialog.fire();
+        return {
+            item,
+            result: promise.p
+        };
+    }
+}
+
+export { DialogsModel };