@codingame/monaco-vscode-dialogs-service-override 2.1.4 → 2.2.0-next.1

package/dialogs.js

@@ -1,10 +1,10 @@
-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 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { AbstractFileDialogService } from './vscode/src/vs/workbench/services/dialogs/browser/abstractFileDialogService.js';
-import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
 import { unsupported } from './tools.js';
+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 {
@@ -50,8 +50,7 @@ class FileDialogService extends AbstractFileDialogService {
 function getServiceOverride() {
     return {
         [( IDialogService.toString())]: new SyncDescriptor(DialogService, undefined, true),
-        [( IFileDialogService.toString())]: new SyncDescriptor(FileDialogService, undefined, true),
-        ...getServiceOverride$1()
+        [( IFileDialogService.toString())]: new SyncDescriptor(FileDialogService, undefined, true)
     };
 }
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-dialogs-service-override",
-  "version": "2.1.4",
+  "version": "2.2.0-next.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,8 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.1.4",
-    "vscode-marked": "npm:marked@=3.0.2",
-    "@codingame/monaco-vscode-layout-service-override": "2.1.4"
+    "vscode": "npm:@codingame/monaco-vscode-api@2.2.0-next.1",
+    "vscode-marked": "npm:marked@=3.0.2"
   }
 }

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,179 @@
+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 { editorWidgetBackground, widgetShadow, widgetBorder, contrastBorder, editorWidgetForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+
+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 };