@codingame/monaco-vscode-dialogs-service-override 4.1.0 → 4.1.2

package/dialogs.js

@@ -1,10 +1,10 @@
-import { DialogService } from 'vscode/vscode/vs/workbench/services/dialogs/common/dialogService';
+import { DialogService } from './vscode/src/vs/workbench/services/dialogs/common/dialogService.js';
 import './override/vs/platform/dialogs/common/dialogs.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { AbstractFileDialogService } from 'vscode/vscode/vs/workbench/services/dialogs/browser/abstractFileDialogService';
+import { AbstractFileDialogService } from './vscode/src/vs/workbench/services/dialogs/browser/abstractFileDialogService.js';
 import { unsupported } from './tools.js';
-import 'vscode/vscode/vs/workbench/browser/parts/dialogs/dialog.web.contribution';
-import 'vscode/vscode/vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution';
+import './vscode/src/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js';
+import './vscode/src/vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution.js';
 import { IDialogService, IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 class FileDialogService extends AbstractFileDialogService {

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n 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/package.json

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

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

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { BrowserDialogHandler } from './dialogHandler.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let DialogHandlerContribution = class DialogHandlerContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.dialogHandler'; }
+    constructor(dialogService, logService, layoutService, keybindingService, instantiationService, productService, clipboardService) {
+        super();
+        this.dialogService = dialogService;
+        this.impl = ( new Lazy(() => ( 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;
+            try {
+                if (this.currentDialog.args.confirmArgs) {
+                    const args = this.currentDialog.args.confirmArgs;
+                    result = await this.impl.value.confirm(args.confirmation);
+                }
+                else if (this.currentDialog.args.inputArgs) {
+                    const args = this.currentDialog.args.inputArgs;
+                    result = await this.impl.value.input(args.input);
+                }
+                else if (this.currentDialog.args.promptArgs) {
+                    const args = this.currentDialog.args.promptArgs;
+                    result = await this.impl.value.prompt(args.prompt);
+                }
+                else {
+                    await this.impl.value.about();
+                }
+            }
+            catch (error) {
+                result = error;
+            }
+            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));
+registerWorkbenchContribution2(DialogHandlerContribution.ID, DialogHandlerContribution, 1 );
+
+export { DialogHandlerContribution };

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

@@ -0,0 +1,134 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { Dialog } from 'vscode/vscode/vs/base/browser/ui/dialog/dialog';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EventHelper } from 'vscode/vscode/vs/base/browser/dom';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+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 ( localizeWithPath(
+                'vs/workbench/browser/parts/dialogs/dialogHandler',
+                '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$1.Info, this.productService.nameLong, [
+            ( localizeWithPath(
+                'vs/workbench/browser/parts/dialogs/dialogHandler',
+                { key: 'copy', comment: ['&& denotes a mnemonic'] },
+                "&&Copy"
+            )),
+            ( localizeWithPath('vs/workbench/browser/parts/dialogs/dialogHandler', '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.activeContainer, message, buttons, {
+            detail,
+            cancelId,
+            type: this.getDialogType(type),
+            keyEventProcessor: (event) => {
+                const resolved = this.keybindingService.softDispatch(event, this.layoutService.activeContainer);
+                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,38 @@
+import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+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);
+                if (result instanceof Error) {
+                    promise.error(result);
+                }
+                else {
+                    promise.complete(result);
+                }
+                this._onDidShowDialog.fire();
+            }
+        };
+        this.dialogs.push(item);
+        this._onWillShowDialog.fire();
+        return {
+            item,
+            result: promise.p
+        };
+    }
+}
+
+export { DialogsModel };

package/vscode/src/vs/workbench/contrib/welcomeDialog/browser/media/welcomeWidget.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-dialog-box{border-radius:6px}.dialog-message-detail-title>div>p>.codicon[class*=codicon-]:before{color:var(--vscode-textLink-foreground);font-size:larger;padding-right:10px;position:relative}.dialog-message-detail-title{font-size:large;height:22px}.monaco-dialog-box .monaco-action-bar .actions-container{justify-content:flex-end}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution.js

@@ -0,0 +1,103 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { WelcomeWidget } from './welcomeWidget.js';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { applicationConfigurationNodeBase } from 'vscode/vscode/vs/workbench/common/configuration';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+const configurationKey = 'workbench.welcome.experimental.dialog';
+let WelcomeDialogContribution = class WelcomeDialogContribution extends Disposable {
+    constructor(storageService, environmentService, configurationService, contextService, codeEditorService, instantiationService, commandService, telemetryService, openerService, editorService) {
+        super();
+        this.contextService = contextService;
+        this.codeEditorService = codeEditorService;
+        this.instantiationService = instantiationService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.openerService = openerService;
+        this.editorService = editorService;
+        this.isRendered = false;
+        if (!storageService.isNew(-1 )) {
+            return;
+        }
+        const setting = configurationService.inspect(configurationKey);
+        if (!setting.value) {
+            return;
+        }
+        const welcomeDialog = environmentService.options?.welcomeDialog;
+        if (!welcomeDialog) {
+            return;
+        }
+        this._register(editorService.onDidActiveEditorChange(() => {
+            if (!this.isRendered) {
+                const codeEditor = codeEditorService.getActiveCodeEditor();
+                if (codeEditor?.hasModel()) {
+                    const scheduler = ( new RunOnceScheduler(() => {
+                        const notificationsVisible = contextService.contextMatchesRules(ContextKeyExpr.deserialize('notificationCenterVisible')) ||
+                            contextService.contextMatchesRules(ContextKeyExpr.deserialize('notificationToastsVisible'));
+                        if (codeEditor === codeEditorService.getActiveCodeEditor() && !notificationsVisible) {
+                            this.isRendered = true;
+                            const welcomeWidget = ( new WelcomeWidget(
+                                codeEditor,
+                                instantiationService,
+                                commandService,
+                                telemetryService,
+                                openerService
+                            ));
+                            welcomeWidget.render(welcomeDialog.title, welcomeDialog.message, welcomeDialog.buttonText, welcomeDialog.buttonCommand);
+                        }
+                    }, 3000));
+                    this._register(codeEditor.onDidChangeModelContent((e) => {
+                        if (!this.isRendered) {
+                            scheduler.schedule();
+                        }
+                    }));
+                }
+            }
+        }));
+    }
+};
+WelcomeDialogContribution = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IBrowserWorkbenchEnvironmentService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IEditorService))
+], WelcomeDialogContribution));
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(WelcomeDialogContribution, 4 );
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    ...applicationConfigurationNodeBase,
+    properties: {
+        'workbench.welcome.experimental.dialog': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            tags: ['experimental'],
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution',
+                'workbench.welcome.dialog',
+                "When enabled, a welcome widget is shown in the editor"
+            ))
+        }
+    }
+});

package/vscode/src/vs/workbench/contrib/welcomeDialog/browser/welcomeWidget.js

@@ -0,0 +1,189 @@
+import './media/welcomeWidget.css.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { $, hide, append } from 'vscode/vscode/vs/base/browser/dom';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { ButtonBar } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { mnemonicButtonLabel } from 'vscode/vscode/vs/base/common/labels';
+import { defaultButtonStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { parseLinkedText } from 'vscode/vscode/vs/base/common/linkedText';
+import { Link } from 'vscode/vscode/vs/platform/opener/browser/link';
+import { renderLabelWithIcons } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { renderFormattedText } from 'vscode/vscode/vs/base/browser/formattedTextRenderer';
+import { registerThemingParticipant } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import { contrastBorder } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorWidgetBackground, widgetShadow, widgetBorder, editorWidgetForeground } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+
+class WelcomeWidget extends Disposable {
+    constructor(_editor, instantiationService, commandService, telemetryService, openerService) {
+        super();
+        this._editor = _editor;
+        this.instantiationService = instantiationService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.openerService = openerService;
+        this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+        this._isVisible = false;
+        this._rootDomNode = document.createElement('div');
+        this._rootDomNode.className = 'welcome-widget';
+        this.element = this._rootDomNode.appendChild($('.monaco-dialog-box'));
+        this.element.setAttribute('role', 'dialog');
+        hide(this._rootDomNode);
+        this.messageContainer = this.element.appendChild($('.dialog-message-container'));
+    }
+    async executeCommand(commandId, ...args) {
+        try {
+            await this.commandService.executeCommand(commandId, ...args);
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: commandId,
+                from: 'welcomeWidget'
+            });
+        }
+        catch (ex) {
+        }
+    }
+    async render(title, message, buttonText, buttonAction) {
+        if (!this._editor._getViewModel()) {
+            return;
+        }
+        await this.buildWidgetContent(title, message, buttonText, buttonAction);
+        this._editor.addOverlayWidget(this);
+        this._show();
+        this.telemetryService.publicLog2('workbenchActionExecuted', {
+            id: 'welcomeWidgetRendered',
+            from: 'welcomeWidget'
+        });
+    }
+    async buildWidgetContent(title, message, buttonText, buttonAction) {
+        const actionBar = this._register(( new ActionBar(this.element, {})));
+        const action = this._register(( new Action('dialog.close', ( localizeWithPath(
+            'vs/workbench/contrib/welcomeDialog/browser/welcomeWidget',
+            'dialogClose',
+            "Close Dialog"
+        )), ThemeIcon.asClassName(Codicon.dialogClose), true, async () => {
+            this._hide();
+        })));
+        actionBar.push(action, { icon: true, label: false });
+        const renderBody = (message, icon) => {
+            const mds = ( new MarkdownString(undefined, { supportThemeIcons: true, supportHtml: true }));
+            mds.appendMarkdown(`<a class="copilot">$(${icon})</a>`);
+            mds.appendMarkdown(message);
+            return mds;
+        };
+        const titleElement = this.messageContainer.appendChild($('#monaco-dialog-message-detail.dialog-message-detail-title'));
+        const titleElementMdt = this.markdownRenderer.render(renderBody(title, 'zap'));
+        titleElement.appendChild(titleElementMdt.element);
+        this.buildStepMarkdownDescription(this.messageContainer, ( message.split('\n').filter(x => x).map(text => parseLinkedText(text))));
+        const buttonsRowElement = this.messageContainer.appendChild($('.dialog-buttons-row'));
+        const buttonContainer = buttonsRowElement.appendChild($('.dialog-buttons'));
+        const buttonBar = this._register(( new ButtonBar(buttonContainer)));
+        const primaryButton = this._register(buttonBar.addButtonWithDescription({ title: true, secondary: false, ...defaultButtonStyles }));
+        primaryButton.label = mnemonicButtonLabel(buttonText, true);
+        this._register(primaryButton.onDidClick(async () => {
+            await this.executeCommand(buttonAction);
+        }));
+        buttonBar.buttons[0].focus();
+    }
+    buildStepMarkdownDescription(container, text) {
+        for (const linkedText of text) {
+            const p = append(container, $('p'));
+            for (const node of linkedText.nodes) {
+                if (typeof node === 'string') {
+                    const labelWithIcon = renderLabelWithIcons(node);
+                    for (const element of labelWithIcon) {
+                        if (typeof element === 'string') {
+                            p.appendChild(renderFormattedText(element, { inline: true, renderCodeSegments: true }));
+                        }
+                        else {
+                            p.appendChild(element);
+                        }
+                    }
+                }
+                else {
+                    const link = this.instantiationService.createInstance(Link, p, node, {
+                        opener: (href) => {
+                            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                                id: 'welcomeWidetLinkAction',
+                                from: 'welcomeWidget'
+                            });
+                            this.openerService.open(href, { allowCommands: true });
+                        }
+                    });
+                    this._register(link);
+                }
+            }
+        }
+        return container;
+    }
+    getId() {
+        return 'editor.contrib.welcomeWidget';
+    }
+    getDomNode() {
+        return this._rootDomNode;
+    }
+    getPosition() {
+        return {
+            preference: 0
+        };
+    }
+    _show() {
+        if (this._isVisible) {
+            return;
+        }
+        this._isVisible = true;
+        this._rootDomNode.style.display = 'block';
+    }
+    _hide() {
+        if (!this._isVisible) {
+            return;
+        }
+        this._isVisible = true;
+        this._rootDomNode.style.display = 'none';
+        this._editor.removeOverlayWidget(this);
+        this.telemetryService.publicLog2('workbenchActionExecuted', {
+            id: 'welcomeWidgetDismissed',
+            from: 'welcomeWidget'
+        });
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const addBackgroundColorRule = (selector, color) => {
+        if (color) {
+            collector.addRule(`.monaco-editor ${selector} { background-color: ${color}; }`);
+        }
+    };
+    const widgetBackground = theme.getColor(editorWidgetBackground);
+    addBackgroundColorRule('.welcome-widget', widgetBackground);
+    const widgetShadowColor = theme.getColor(widgetShadow);
+    if (widgetShadowColor) {
+        collector.addRule(`.welcome-widget { box-shadow: 0 0 8px 2px ${widgetShadowColor}; }`);
+    }
+    const widgetBorderColor = theme.getColor(widgetBorder);
+    if (widgetBorderColor) {
+        collector.addRule(`.welcome-widget { border-left: 1px solid ${widgetBorderColor}; border-right: 1px solid ${widgetBorderColor}; border-bottom: 1px solid ${widgetBorderColor}; }`);
+    }
+    const hcBorder = theme.getColor(contrastBorder);
+    if (hcBorder) {
+        collector.addRule(`.welcome-widget { border: 1px solid ${hcBorder}; }`);
+    }
+    const foreground = theme.getColor(editorWidgetForeground);
+    if (foreground) {
+        collector.addRule(`.welcome-widget { color: ${foreground}; }`);
+    }
+});
+
+export { WelcomeWidget };