npm - @codingame/monaco-vscode-dialogs-service-override - Versions diffs - 4.5.0 → 4.5.2 - Mend

@codingame/monaco-vscode-dialogs-service-override 4.5.0 → 4.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/index.d.ts CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-dialogs-service-override",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.2"
   }
 }

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

@@ -16,6 +16,7 @@ import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdow
 import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
 var BrowserDialogHandler_1;
+const _moduleId = "vs/workbench/browser/parts/dialogs/dialogHandler";
 let BrowserDialogHandler = class BrowserDialogHandler extends AbstractDialogHandler {
     static { BrowserDialogHandler_1 = this; }
     static { this.ALLOWABLE_COMMANDS = [
@@ -57,31 +58,27 @@ let BrowserDialogHandler = class BrowserDialogHandler extends AbstractDialogHand
     async about() {
         const detailString = (useAgo) => {
             return ( localizeWithPath(
-                'vs/workbench/browser/parts/dialogs/dialogHandler',
-                'aboutDetail',
+                _moduleId,
+                0,
                 "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',
+                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"))
+            ( localizeWithPath(_moduleId, 1, "&&Copy")),
+            ( localizeWithPath(_moduleId, 2, "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 dialogDisposables = ( (new DisposableStore()));
         const renderBody = customOptions ? (parent) => {
             parent.classList.add(...(customOptions.classes || []));
             customOptions.markdownDetails?.forEach(markdownDetail => {
@@ -91,7 +88,7 @@ let BrowserDialogHandler = class BrowserDialogHandler extends AbstractDialogHand
                 dialogDisposables.add(result);
             });
         } : undefined;
-        const dialog = ( new Dialog(this.layoutService.activeContainer, message, buttons, {
+        const dialog = ( (new Dialog(this.layoutService.activeContainer, message, buttons, {
             detail,
             cancelId,
             type: this.getDialogType(type),
@@ -114,20 +111,20 @@ let BrowserDialogHandler = class BrowserDialogHandler extends AbstractDialogHand
             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));
+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/contrib/welcomeDialog/browser/welcomeDialog.contribution.js CHANGED Viewed

@@ -19,6 +19,7 @@ import { applicationConfigurationNodeBase } from 'vscode/vscode/vs/workbench/com
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+const _moduleId = "vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution";
 const configurationKey = 'workbench.welcome.experimental.dialog';
 let WelcomeDialogContribution = class WelcomeDialogContribution extends Disposable {
     constructor(storageService, environmentService, configurationService, contextService, codeEditorService, instantiationService, commandService, telemetryService, openerService, editorService) {
@@ -46,21 +47,21 @@ let WelcomeDialogContribution = class WelcomeDialogContribution extends Disposab
             if (!this.isRendered) {
                 const codeEditor = codeEditorService.getActiveCodeEditor();
                 if (codeEditor?.hasModel()) {
-                    const scheduler = ( new RunOnceScheduler(() => {
+                    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(
+                            const welcomeWidget = ( (new WelcomeWidget(
                                 codeEditor,
                                 instantiationService,
                                 commandService,
                                 telemetryService,
                                 openerService
-                            ));
+                            )));
                             welcomeWidget.render(welcomeDialog.title, welcomeDialog.message, welcomeDialog.buttonText, welcomeDialog.buttonCommand);
                         }
-                    }, 3000));
+                    }, 3000)));
                     this._register(codeEditor.onDidChangeModelContent((e) => {
                         if (!this.isRendered) {
                             scheduler.schedule();
@@ -71,21 +72,21 @@ let WelcomeDialogContribution = class WelcomeDialogContribution extends Disposab
         }));
     }
 };
-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))
+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));
+const configurationRegistry = ( (Registry.as(Extensions$1.Configuration)));
 configurationRegistry.registerConfiguration({
     ...applicationConfigurationNodeBase,
     properties: {
@@ -94,11 +95,7 @@ configurationRegistry.registerConfiguration({
             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"
-            ))
+            description: ( localizeWithPath(_moduleId, 0, "When enabled, a welcome widget is shown in the editor"))
         }
     }
 });

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

@@ -28,6 +28,7 @@ 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';
+const _moduleId = "vs/workbench/contrib/welcomeDialog/browser/welcomeWidget";
 class WelcomeWidget extends Disposable {
     constructor(_editor, instantiationService, commandService, telemetryService, openerService) {
         super();
@@ -69,17 +70,13 @@ class WelcomeWidget extends Disposable {
         });
     }
     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 () => {
+        const actionBar = this._register(( (new ActionBar(this.element, {}))));
+        const action = this._register(( (new Action('dialog.close', ( localizeWithPath(_moduleId, 0, "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 }));
+            const mds = ( (new MarkdownString(undefined, { supportThemeIcons: true, supportHtml: true })));
             mds.appendMarkdown(`<a class="copilot">$(${icon})</a>`);
             mds.appendMarkdown(message);
             return mds;
@@ -87,10 +84,10 @@ class WelcomeWidget extends Disposable {
         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))));
+        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 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 () => {

package/vscode/src/vs/workbench/services/dialogs/browser/abstractFileDialogService.js CHANGED Viewed

@@ -30,6 +30,7 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { EditorOpenSource } from 'vscode/vscode/vs/platform/editor/common/editor';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+const _moduleId = "vs/workbench/services/dialogs/browser/abstractFileDialogService";
 let AbstractFileDialogService = class AbstractFileDialogService {
     constructor(hostService, contextService, historyService, environmentService, instantiationService, configurationService, fileService, openerService, dialogService, languageService, workspacesService, labelService, pathService, commandService, editorService, codeEditorService, logService) {
         this.hostService = hostService;
@@ -120,23 +121,19 @@ let AbstractFileDialogService = class AbstractFileDialogService {
             return 1 ;
         }
         let message;
-        let detail = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'saveChangesDetail',
-            "Your changes will be lost if you don't save them."
-        ));
+        let detail = ( localizeWithPath(_moduleId, 0, "Your changes will be lost if you don't save them."));
         if (fileNamesOrResources.length === 1) {
             message = ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                'saveChangesMessage',
+                _moduleId,
+                1,
                 "Do you want to save the changes you made to {0}?",
                 typeof fileNamesOrResources[0] === 'string' ? fileNamesOrResources[0] : basename(fileNamesOrResources[0])
             ));
         }
         else {
             message = ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                'saveChangesMessages',
+                _moduleId,
+                2,
                 "Do you want to save the changes to the following {0} files?",
                 fileNamesOrResources.length
             ));
@@ -149,24 +146,12 @@ let AbstractFileDialogService = class AbstractFileDialogService {
             buttons: [
                 {
                     label: fileNamesOrResources.length > 1 ?
-                        ( localizeWithPath(
-                            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                            { key: 'saveAll', comment: ['&& denotes a mnemonic'] },
-                            "&&Save All"
-                        )) :
-                        ( localizeWithPath(
-                            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                            { key: 'save', comment: ['&& denotes a mnemonic'] },
-                            "&&Save"
-                        )),
+                        ( localizeWithPath(_moduleId, 3, "&&Save All")) :
+                        ( localizeWithPath(_moduleId, 4, "&&Save")),
                     run: () => 0
                 },
                 {
-                    label: ( localizeWithPath(
-                        'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                        { key: 'dontSave', comment: ['&& denotes a mnemonic'] },
-                        "Do&&n't Save"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 5, "Do&&n't Save")),
                     run: () => 1
                 }
             ],
@@ -180,11 +165,7 @@ let AbstractFileDialogService = class AbstractFileDialogService {
         return schema === Schemas.untitled ? [Schemas.file] : (schema !== Schemas.file ? [schema, Schemas.file] : [schema]);
     }
     async pickFileFolderAndOpenSimplified(schema, options, preferNewWindow) {
-        const title = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'openFileOrFolder.title',
-            'Open File or Folder'
-        ));
+        const title = ( localizeWithPath(_moduleId, 6, 'Open File or Folder'));
         const availableFileSystems = this.addFileSchemaIfNeeded(schema);
         const uri = await this.pickResource({ canSelectFiles: true, canSelectFolders: true, canSelectMany: false, defaultUri: options.defaultUri, title, availableFileSystems });
         if (uri) {
@@ -202,11 +183,7 @@ let AbstractFileDialogService = class AbstractFileDialogService {
         }
     }
     async pickFileAndOpenSimplified(schema, options, preferNewWindow) {
-        const title = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'openFile.title',
-            'Open File'
-        ));
+        const title = ( localizeWithPath(_moduleId, 7, 'Open File'));
         const availableFileSystems = this.addFileSchemaIfNeeded(schema);
         const uri = await this.pickResource({ canSelectFiles: true, canSelectFolders: false, canSelectMany: false, defaultUri: options.defaultUri, title, availableFileSystems });
         if (uri) {
@@ -223,11 +200,7 @@ let AbstractFileDialogService = class AbstractFileDialogService {
         this.workspacesService.addRecentlyOpened([{ fileUri: uri, label: this.labelService.getUriLabel(uri) }]);
     }
     async pickFolderAndOpenSimplified(schema, options) {
-        const title = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'openFolder.title',
-            'Open Folder'
-        ));
+        const title = ( localizeWithPath(_moduleId, 8, 'Open Folder'));
         const availableFileSystems = this.addFileSchemaIfNeeded(schema, true);
         const uri = await this.pickResource({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, defaultUri: options.defaultUri, title, availableFileSystems });
         if (uri) {
@@ -235,16 +208,8 @@ let AbstractFileDialogService = class AbstractFileDialogService {
         }
     }
     async pickWorkspaceAndOpenSimplified(schema, options) {
-        const title = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'openWorkspace.title',
-            'Open Workspace from File'
-        ));
-        const filters = [{ name: ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'filterName.workspace',
-            'Workspace'
-        )), extensions: [WORKSPACE_EXTENSION] }];
+        const title = ( localizeWithPath(_moduleId, 9, 'Open Workspace from File'));
+        const filters = [{ name: ( localizeWithPath(_moduleId, 10, 'Workspace')), extensions: [WORKSPACE_EXTENSION] }];
         const availableFileSystems = this.addFileSchemaIfNeeded(schema, true);
         const uri = await this.pickResource({ canSelectFiles: true, canSelectFolders: false, canSelectMany: false, defaultUri: options.defaultUri, title, filters, availableFileSystems });
         if (uri) {
@@ -255,11 +220,7 @@ let AbstractFileDialogService = class AbstractFileDialogService {
         if (!options.availableFileSystems) {
             options.availableFileSystems = this.addFileSchemaIfNeeded(schema);
         }
-        options.title = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-            'saveFileAs.title',
-            'Save As'
-        ));
+        options.title = ( localizeWithPath(_moduleId, 11, 'Save As'));
         const uri = await this.saveRemoteResource(options);
         if (uri) {
             this.addFileToRecentlyOpened(uri);
@@ -310,22 +271,18 @@ let AbstractFileDialogService = class AbstractFileDialogService {
     getPickFileToSaveDialogOptions(defaultUri, availableFileSystems) {
         const options = {
             defaultUri,
-            title: ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                'saveAsTitle',
-                "Save As"
-            )),
+            title: ( localizeWithPath(_moduleId, 12, "Save As")),
             availableFileSystems
         };
         const ext = defaultUri ? extname(defaultUri) : undefined;
         let matchingFilter;
         const registeredLanguageNames = this.languageService.getSortedRegisteredLanguageNames();
-        const registeredLanguageFilters = coalesce(( registeredLanguageNames.map(({ languageName, languageId }) => {
+        const registeredLanguageFilters = coalesce(( (registeredLanguageNames.map(({ languageName, languageId }) => {
             const extensions = this.languageService.getExtensions(languageId);
             if (!extensions.length) {
                 return null;
             }
-            const filter = { name: languageName, extensions: ( distinct(extensions).slice(0, 10).map(e => trim(e, '.'))) };
+            const filter = { name: languageName, extensions: ( (distinct(extensions).slice(0, 10).map(e => trim(e, '.')))) };
             const extOrPlaintext = ext || PLAINTEXT_EXTENSION;
             if (!matchingFilter && extensions.includes(extOrPlaintext)) {
                 matchingFilter = filter;
@@ -336,45 +293,37 @@ let AbstractFileDialogService = class AbstractFileDialogService {
                 return null;
             }
             return filter;
-        })));
+        }))));
         if (!matchingFilter && ext) {
             matchingFilter = { name: trim(ext, '.').toUpperCase(), extensions: [trim(ext, '.')] };
         }
         options.filters = coalesce([
-            { name: ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                'allFiles',
-                "All Files"
-            )), extensions: ['*'] },
+            { name: ( localizeWithPath(_moduleId, 13, "All Files")), extensions: ['*'] },
             matchingFilter,
             ...registeredLanguageFilters,
-            { name: ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
-                'noExt',
-                "No Extension"
-            )), extensions: [''] }
+            { name: ( localizeWithPath(_moduleId, 14, "No Extension")), extensions: [''] }
         ]);
         return options;
     }
 };
-AbstractFileDialogService = ( __decorate([
-    ( __param(0, IHostService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IHistoryService)),
-    ( __param(3, IWorkbenchEnvironmentService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IFileService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IDialogService)),
-    ( __param(9, ILanguageService)),
-    ( __param(10, IWorkspacesService)),
-    ( __param(11, ILabelService)),
-    ( __param(12, IPathService)),
-    ( __param(13, ICommandService)),
-    ( __param(14, IEditorService)),
-    ( __param(15, ICodeEditorService)),
-    ( __param(16, ILogService))
-], AbstractFileDialogService));
+AbstractFileDialogService = ( (__decorate([
+    ( (__param(0, IHostService))),
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IHistoryService))),
+    ( (__param(3, IWorkbenchEnvironmentService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IFileService))),
+    ( (__param(7, IOpenerService))),
+    ( (__param(8, IDialogService))),
+    ( (__param(9, ILanguageService))),
+    ( (__param(10, IWorkspacesService))),
+    ( (__param(11, ILabelService))),
+    ( (__param(12, IPathService))),
+    ( (__param(13, ICommandService))),
+    ( (__param(14, IEditorService))),
+    ( (__param(15, ICodeEditorService))),
+    ( (__param(16, ILogService)))
+], AbstractFileDialogService)));
 export { AbstractFileDialogService };

package/vscode/src/vs/workbench/services/dialogs/browser/fileDialogService.js CHANGED Viewed

@@ -14,6 +14,7 @@ import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { WebFileSystemAccess } from 'vscode/vscode/vs/platform/files/browser/webFileSystemAccess';
 import { EmbeddedCodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+const _moduleId = "vs/workbench/services/dialogs/browser/fileDialogService";
 class FileDialogService extends AbstractFileDialogService {
     get fileSystemProvider() {
         return this.fileService.getProvider(Schemas.file);
@@ -26,7 +27,11 @@ class FileDialogService extends AbstractFileDialogService {
         if (this.shouldUseSimplified(schema)) {
             return super.pickFileFolderAndOpenSimplified(schema, options, false);
         }
-        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickFolderAndOpen', "Can't open folders, try adding a folder to the workspace instead."));
+        throw ( (new Error(localizeWithPath(
+            _moduleId,
+            0,
+            "Can't open folders, try adding a folder to the workspace instead."
+        ))));
     }
     addFileSchemaIfNeeded(schema, isFolder) {
         return (schema === Schemas.untitled) ? [Schemas.file]
@@ -66,7 +71,11 @@ class FileDialogService extends AbstractFileDialogService {
         if (this.shouldUseSimplified(schema)) {
             return super.pickFolderAndOpenSimplified(schema, options);
         }
-        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickFolderAndOpen', "Can't open folders, try adding a folder to the workspace instead."));
+        throw ( (new Error(localizeWithPath(
+            _moduleId,
+            0,
+            "Can't open folders, try adding a folder to the workspace instead."
+        ))));
     }
     async pickWorkspaceAndOpen(options) {
         options.availableFileSystems = this.getWorkspaceAvailableFileSystems(options);
@@ -77,7 +86,11 @@ class FileDialogService extends AbstractFileDialogService {
         if (this.shouldUseSimplified(schema)) {
             return super.pickWorkspaceAndOpenSimplified(schema, options);
         }
-        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickWorkspaceAndOpen', "Can't open workspaces, try adding a folder to the workspace instead."));
+        throw ( (new Error(localizeWithPath(
+            _moduleId,
+            1,
+            "Can't open workspaces, try adding a folder to the workspace instead."
+        ))));
     }
     async pickFileToSave(defaultUri, availableFileSystems) {
         const schema = this.getFileSystemSchema({ defaultUri, availableFileSystems });
@@ -108,7 +121,7 @@ class FileDialogService extends AbstractFileDialogService {
         }).map(filter => {
             const accept = {};
             const extensions = filter.extensions.filter(ext => (ext.indexOf('-') < 0) && (ext.indexOf('*') < 0) && (ext.indexOf('_') < 0));
-            accept[getMediaOrTextMime(`fileName.${filter.extensions[0]}`) ?? 'text/plain'] = ( extensions.map(ext => ext.startsWith('.') ? ext : `.${ext}`));
+            accept[getMediaOrTextMime(`fileName.${filter.extensions[0]}`) ?? 'text/plain'] = ( (extensions.map(ext => ext.startsWith('.') ? ext : `.${ext}`)));
             return {
                 description: filter.name,
                 accept
@@ -177,41 +190,29 @@ class FileDialogService extends AbstractFileDialogService {
         }
         const buttons = [
             {
-                label: ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/fileDialogService',
-                    { key: 'openRemote', comment: ['&& denotes a mnemonic'] },
-                    "&&Open Remote..."
-                )),
+                label: ( localizeWithPath(_moduleId, 2, "&&Open Remote...")),
                 run: async () => { await this.commandService.executeCommand('workbench.action.remote.showMenu'); }
             },
             {
-                label: ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/fileDialogService',
-                    { key: 'learnMore', comment: ['&& denotes a mnemonic'] },
-                    "&&Learn More"
-                )),
+                label: ( localizeWithPath(_moduleId, 3, "&&Learn More")),
                 run: async () => { await this.openerService.open('https://aka.ms/VSCodeWebLocalFileSystemAccess'); }
             }
         ];
         if (context === 'open') {
             buttons.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/fileDialogService',
-                    { key: 'openFiles', comment: ['&& denotes a mnemonic'] },
-                    "Open &&Files..."
-                )),
+                label: ( localizeWithPath(_moduleId, 4, "Open &&Files...")),
                 run: async () => {
                     const files = await triggerUpload();
                     if (files) {
                         const filesData = (await this.instantiationService.invokeFunction(accessor => extractFileListData(accessor, files))).filter(fileData => !fileData.isDirectory);
                         if (filesData.length > 0) {
-                            this.editorService.openEditors(( filesData.map(fileData => {
+                            this.editorService.openEditors(( (filesData.map(fileData => {
                                 return {
                                     resource: fileData.resource,
                                     contents: fileData.contents?.toString(),
                                     options: { pinned: true }
                                 };
-                            })));
+                            }))));
                         }
                     }
                 }
@@ -219,14 +220,10 @@ class FileDialogService extends AbstractFileDialogService {
         }
         await this.dialogService.prompt({
             type: Severity$1.Warning,
-            message: ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/fileDialogService',
-                'unsupportedBrowserMessage',
-                "Opening Local Folders is Unsupported"
-            )),
+            message: ( localizeWithPath(_moduleId, 5, "Opening Local Folders is Unsupported")),
             detail: ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/fileDialogService',
-                'unsupportedBrowserDetail',
+                _moduleId,
+                6,
                 "Your browser doesn't support opening local folders.\nYou can either open single files or open a remote repository."
             )),
             buttons
@@ -237,8 +234,8 @@ class FileDialogService extends AbstractFileDialogService {
         return ![Schemas.file, Schemas.vscodeUserData, Schemas.tmp].includes(scheme);
     }
 }
-FileDialogService.__decorator = ( __decorate([
+FileDialogService.__decorator = ( (__decorate([
     memoize
-], FileDialogService.prototype, "fileSystemProvider", null));
+], FileDialogService.prototype, "fileSystemProvider", null)));
 export { FileDialogService };

package/vscode/src/vs/workbench/services/dialogs/browser/simpleFileDialog.js CHANGED Viewed

@@ -32,14 +32,11 @@ import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pa
 import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
 import { getActiveDocument } from 'vscode/vscode/vs/base/browser/dom';
+const _moduleId = "vs/workbench/services/dialogs/browser/simpleFileDialog";
 var OpenLocalFileCommand;
-( (function(OpenLocalFileCommand) {
+( ((function(OpenLocalFileCommand) {
     OpenLocalFileCommand.ID = 'workbench.action.files.openLocalFile';
-    OpenLocalFileCommand.LABEL = ( localizeWithPath(
-        'vs/workbench/services/dialogs/browser/simpleFileDialog',
-        'openLocalFile',
-        "Open Local File..."
-    ));
+    OpenLocalFileCommand.LABEL = ( localizeWithPath(_moduleId, 0, "Open Local File..."));
     function handler() {
         return accessor => {
             const dialogService = accessor.get(IFileDialogService);
@@ -47,15 +44,11 @@ var OpenLocalFileCommand;
         };
     }
     OpenLocalFileCommand.handler = handler;
-})(OpenLocalFileCommand || (OpenLocalFileCommand = {})));
+})(OpenLocalFileCommand || (OpenLocalFileCommand = {}))));
 var SaveLocalFileCommand;
-( (function(SaveLocalFileCommand) {
+( ((function(SaveLocalFileCommand) {
     SaveLocalFileCommand.ID = 'workbench.action.files.saveLocalFile';
-    SaveLocalFileCommand.LABEL = ( localizeWithPath(
-        'vs/workbench/services/dialogs/browser/simpleFileDialog',
-        'saveLocalFile',
-        "Save Local File..."
-    ));
+    SaveLocalFileCommand.LABEL = ( localizeWithPath(_moduleId, 1, "Save Local File..."));
     function handler() {
         return accessor => {
             const editorService = accessor.get(IEditorService);
@@ -67,15 +60,11 @@ var SaveLocalFileCommand;
         };
     }
     SaveLocalFileCommand.handler = handler;
-})(SaveLocalFileCommand || (SaveLocalFileCommand = {})));
+})(SaveLocalFileCommand || (SaveLocalFileCommand = {}))));
 var OpenLocalFolderCommand;
-( (function(OpenLocalFolderCommand) {
+( ((function(OpenLocalFolderCommand) {
     OpenLocalFolderCommand.ID = 'workbench.action.files.openLocalFolder';
-    OpenLocalFolderCommand.LABEL = ( localizeWithPath(
-        'vs/workbench/services/dialogs/browser/simpleFileDialog',
-        'openLocalFolder',
-        "Open Local Folder..."
-    ));
+    OpenLocalFolderCommand.LABEL = ( localizeWithPath(_moduleId, 2, "Open Local Folder..."));
     function handler() {
         return accessor => {
             const dialogService = accessor.get(IFileDialogService);
@@ -83,15 +72,11 @@ var OpenLocalFolderCommand;
         };
     }
     OpenLocalFolderCommand.handler = handler;
-})(OpenLocalFolderCommand || (OpenLocalFolderCommand = {})));
+})(OpenLocalFolderCommand || (OpenLocalFolderCommand = {}))));
 var OpenLocalFileFolderCommand;
-( (function(OpenLocalFileFolderCommand) {
+( ((function(OpenLocalFileFolderCommand) {
     OpenLocalFileFolderCommand.ID = 'workbench.action.files.openLocalFileFolder';
-    OpenLocalFileFolderCommand.LABEL = ( localizeWithPath(
-        'vs/workbench/services/dialogs/browser/simpleFileDialog',
-        'openLocalFileFolder',
-        "Open Local..."
-    ));
+    OpenLocalFileFolderCommand.LABEL = ( localizeWithPath(_moduleId, 3, "Open Local..."));
     function handler() {
         return accessor => {
             const dialogService = accessor.get(IFileDialogService);
@@ -99,16 +84,16 @@ var OpenLocalFileFolderCommand;
         };
     }
     OpenLocalFileFolderCommand.handler = handler;
-})(OpenLocalFileFolderCommand || (OpenLocalFileFolderCommand = {})));
+})(OpenLocalFileFolderCommand || (OpenLocalFileFolderCommand = {}))));
 var UpdateResult;
-( (function(UpdateResult) {
+( ((function(UpdateResult) {
     UpdateResult[UpdateResult["Updated"] = 0] = "Updated";
     UpdateResult[UpdateResult["UpdatedWithTrailing"] = 1] = "UpdatedWithTrailing";
     UpdateResult[UpdateResult["Updating"] = 2] = "Updating";
     UpdateResult[UpdateResult["NotUpdated"] = 3] = "NotUpdated";
     UpdateResult[UpdateResult["InvalidPath"] = 4] = "InvalidPath";
-})(UpdateResult || (UpdateResult = {})));
-const RemoteFileDialogContext = ( new RawContextKey('remoteFileDialogVisible', false));
+})(UpdateResult || (UpdateResult = {}))));
+const RemoteFileDialogContext = ( (new RawContextKey('remoteFileDialogVisible', false)));
 let SimpleFileDialog = class SimpleFileDialog {
     constructor(fileService, quickInputService, labelService, workspaceContextService, notificationService, fileDialogService, modelService, languageService, environmentService, remoteAgentService, pathService, keybindingService, contextKeyService, accessibilityService) {
         this.fileService = fileService;
@@ -132,7 +117,7 @@ let SimpleFileDialog = class SimpleFileDialog {
         this.autoCompletePathSegment = '';
         this.isWindows = false;
         this.separator = '/';
-        this.onBusyChangeEmitter = ( new Emitter());
+        this.onBusyChangeEmitter = ( (new Emitter()));
         this.disposables = [
             this.onBusyChangeEmitter
         ];
@@ -172,11 +157,13 @@ let SimpleFileDialog = class SimpleFileDialog {
         this.options = newOptions;
         this.options.canSelectFolders = true;
         this.options.canSelectFiles = true;
-        return ( new Promise((resolve) => {
-            this.pickResource(true).then(folderUri => {
-                resolve(folderUri);
-            });
-        }));
+        return (
+             (new Promise((resolve) => {
+                this.pickResource(true).then(folderUri => {
+                    resolve(folderUri);
+                });
+            }))
+        );
     }
     getOptions(options, isSave = false) {
         let defaultUri = undefined;
@@ -193,10 +180,10 @@ let SimpleFileDialog = class SimpleFileDialog {
         }
         if ((this.scheme !== Schemas.file) && !this.fileService.hasProvider(defaultUri)) {
             this.notificationService.info(( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                'remoteFileDialog.notConnectedToRemote',
+                _moduleId,
+                4,
                 'File system provider for {0} is not available.',
-                ( defaultUri.toString())
+                 (defaultUri.toString())
             )));
             return undefined;
         }
@@ -208,9 +195,9 @@ let SimpleFileDialog = class SimpleFileDialog {
         if (!path.startsWith('\\\\')) {
             path = path.replace(/\\/g, '/');
         }
-        const uri = this.scheme === Schemas.file ? URI.file(path) : ( URI.from(
+        const uri = this.scheme === Schemas.file ? URI.file(path) : ( (URI.from(
             { scheme: this.scheme, path, query: hintUri?.query, fragment: hintUri?.fragment }
-        ));
+        )));
         const authority = (uri.scheme === Schemas.file) ? undefined : (this.remoteAuthority ?? hintUri?.authority);
         return toLocalResource(uri, authority,
         authority ? this.pathService.defaultUriScheme : uri.scheme);
@@ -258,138 +245,136 @@ let SimpleFileDialog = class SimpleFileDialog {
                 this.trailing = basename(this.options.defaultUri);
             }
         }
-        return ( new Promise((resolve) => {
-            this.filePickBox = this.quickInputService.createQuickPick();
-            this.busy = true;
-            this.filePickBox.matchOnLabel = false;
-            this.filePickBox.sortByLabel = false;
-            this.filePickBox.ignoreFocusOut = true;
-            this.filePickBox.ok = true;
-            if ((this.scheme !== Schemas.file) && this.options && this.options.availableFileSystems && (this.options.availableFileSystems.length > 1) && (this.options.availableFileSystems.indexOf(Schemas.file) > -1)) {
-                this.filePickBox.customButton = true;
-                this.filePickBox.customLabel = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.local',
-                    'Show Local'
-                ));
-                let action;
-                if (isSave) {
-                    action = SaveLocalFileCommand;
-                }
-                else {
-                    action = this.allowFileSelection ? (this.allowFolderSelection ? OpenLocalFileFolderCommand : OpenLocalFileCommand) : OpenLocalFolderCommand;
-                }
-                const keybinding = this.keybindingService.lookupKeybinding(action.ID);
-                if (keybinding) {
-                    const label = keybinding.getLabel();
-                    if (label) {
-                        this.filePickBox.customHover = format('{0} ({1})', action.LABEL, label);
+        return (
+             (new Promise((resolve) => {
+                this.filePickBox = this.quickInputService.createQuickPick();
+                this.busy = true;
+                this.filePickBox.matchOnLabel = false;
+                this.filePickBox.sortByLabel = false;
+                this.filePickBox.ignoreFocusOut = true;
+                this.filePickBox.ok = true;
+                if ((this.scheme !== Schemas.file) && this.options && this.options.availableFileSystems && (this.options.availableFileSystems.length > 1) && (this.options.availableFileSystems.indexOf(Schemas.file) > -1)) {
+                    this.filePickBox.customButton = true;
+                    this.filePickBox.customLabel = ( localizeWithPath(_moduleId, 5, 'Show Local'));
+                    let action;
+                    if (isSave) {
+                        action = SaveLocalFileCommand;
                     }
-                }
-            }
-            let isResolving = 0;
-            let isAcceptHandled = false;
-            this.currentFolder = dirname(homedir);
-            this.userEnteredPathSegment = '';
-            this.autoCompletePathSegment = '';
-            this.filePickBox.title = this.options.title;
-            this.filePickBox.value = this.pathFromUri(this.currentFolder, true);
-            this.filePickBox.valueSelection = [this.filePickBox.value.length, this.filePickBox.value.length];
-            function doResolve(dialog, uri) {
-                if (uri) {
-                    uri = addTrailingPathSeparator(uri, dialog.separator);
-                    uri = removeTrailingPathSeparator(uri);
-                }
-                resolve(uri);
-                dialog.contextKey.set(false);
-                dialog.filePickBox.dispose();
-                dispose(dialog.disposables);
-            }
-            this.filePickBox.onDidCustom(() => {
-                if (isAcceptHandled || this.busy) {
-                    return;
-                }
-                isAcceptHandled = true;
-                isResolving++;
-                if (this.options.availableFileSystems && (this.options.availableFileSystems.length > 1)) {
-                    this.options.availableFileSystems = this.options.availableFileSystems.slice(1);
-                }
-                this.filePickBox.hide();
-                if (isSave) {
-                    return this.fileDialogService.showSaveDialog(this.options).then(result => {
-                        doResolve(this, result);
-                    });
-                }
-                else {
-                    return this.fileDialogService.showOpenDialog(this.options).then(result => {
-                        doResolve(this, result ? result[0] : undefined);
-                    });
-                }
-            });
-            function handleAccept(dialog) {
-                if (dialog.busy) {
-                    dialog.onBusyChangeEmitter.event((busy) => {
-                        if (!busy) {
-                            handleAccept(dialog);
+                    else {
+                        action = this.allowFileSelection ? (this.allowFolderSelection ? OpenLocalFileFolderCommand : OpenLocalFileCommand) : OpenLocalFolderCommand;
+                    }
+                    const keybinding = this.keybindingService.lookupKeybinding(action.ID);
+                    if (keybinding) {
+                        const label = keybinding.getLabel();
+                        if (label) {
+                            this.filePickBox.customHover = format('{0} ({1})', action.LABEL, label);
                         }
-                    });
-                    return;
-                }
-                else if (isAcceptHandled) {
-                    return;
+                    }
                 }
-                isAcceptHandled = true;
-                isResolving++;
-                dialog.onDidAccept().then(resolveValue => {
-                    if (resolveValue) {
-                        dialog.filePickBox.hide();
-                        doResolve(dialog, resolveValue);
+                let isResolving = 0;
+                let isAcceptHandled = false;
+                this.currentFolder = dirname(homedir);
+                this.userEnteredPathSegment = '';
+                this.autoCompletePathSegment = '';
+                this.filePickBox.title = this.options.title;
+                this.filePickBox.value = this.pathFromUri(this.currentFolder, true);
+                this.filePickBox.valueSelection = [this.filePickBox.value.length, this.filePickBox.value.length];
+                function doResolve(dialog, uri) {
+                    if (uri) {
+                        uri = addTrailingPathSeparator(uri, dialog.separator);
+                        uri = removeTrailingPathSeparator(uri);
+                    }
+                    resolve(uri);
+                    dialog.contextKey.set(false);
+                    dialog.filePickBox.dispose();
+                    dispose(dialog.disposables);
+                }
+                this.filePickBox.onDidCustom(() => {
+                    if (isAcceptHandled || this.busy) {
+                        return;
+                    }
+                    isAcceptHandled = true;
+                    isResolving++;
+                    if (this.options.availableFileSystems && (this.options.availableFileSystems.length > 1)) {
+                        this.options.availableFileSystems = this.options.availableFileSystems.slice(1);
                     }
-                    else if (dialog.hidden) {
-                        doResolve(dialog, undefined);
+                    this.filePickBox.hide();
+                    if (isSave) {
+                        return this.fileDialogService.showSaveDialog(this.options).then(result => {
+                            doResolve(this, result);
+                        });
                     }
                     else {
-                        isResolving--;
-                        isAcceptHandled = false;
+                        return this.fileDialogService.showOpenDialog(this.options).then(result => {
+                            doResolve(this, result ? result[0] : undefined);
+                        });
                     }
                 });
-            }
-            this.filePickBox.onDidAccept(_ => {
-                handleAccept(this);
-            });
-            this.filePickBox.onDidChangeActive(i => {
-                isAcceptHandled = false;
-                if ((i.length === 1) && this.isSelectionChangeFromUser()) {
-                    this.filePickBox.validationMessage = undefined;
-                    const userPath = this.constructFullUserPath();
-                    if (!equalsIgnoreCase(this.filePickBox.value.substring(0, userPath.length), userPath)) {
-                        this.filePickBox.valueSelection = [0, this.filePickBox.value.length];
-                        this.insertText(userPath, userPath);
+                function handleAccept(dialog) {
+                    if (dialog.busy) {
+                        dialog.onBusyChangeEmitter.event((busy) => {
+                            if (!busy) {
+                                handleAccept(dialog);
+                            }
+                        });
+                        return;
                     }
-                    this.setAutoComplete(userPath, this.userEnteredPathSegment, i[0], true);
-                }
-            });
-            this.filePickBox.onDidChangeValue(async (value) => {
-                return this.handleValueChange(value);
-            });
-            this.filePickBox.onDidHide(() => {
-                this.hidden = true;
-                if (isResolving === 0) {
-                    doResolve(this, undefined);
-                }
-            });
-            this.filePickBox.show();
-            this.contextKey.set(true);
-            this.updateItems(homedir, true, this.trailing).then(() => {
-                if (this.trailing) {
-                    this.filePickBox.valueSelection = [this.filePickBox.value.length - this.trailing.length, this.filePickBox.value.length - ext.length];
-                }
-                else {
-                    this.filePickBox.valueSelection = [this.filePickBox.value.length, this.filePickBox.value.length];
+                    else if (isAcceptHandled) {
+                        return;
+                    }
+                    isAcceptHandled = true;
+                    isResolving++;
+                    dialog.onDidAccept().then(resolveValue => {
+                        if (resolveValue) {
+                            dialog.filePickBox.hide();
+                            doResolve(dialog, resolveValue);
+                        }
+                        else if (dialog.hidden) {
+                            doResolve(dialog, undefined);
+                        }
+                        else {
+                            isResolving--;
+                            isAcceptHandled = false;
+                        }
+                    });
                 }
-                this.busy = false;
-            });
-        }));
+                this.filePickBox.onDidAccept(_ => {
+                    handleAccept(this);
+                });
+                this.filePickBox.onDidChangeActive(i => {
+                    isAcceptHandled = false;
+                    if ((i.length === 1) && this.isSelectionChangeFromUser()) {
+                        this.filePickBox.validationMessage = undefined;
+                        const userPath = this.constructFullUserPath();
+                        if (!equalsIgnoreCase(this.filePickBox.value.substring(0, userPath.length), userPath)) {
+                            this.filePickBox.valueSelection = [0, this.filePickBox.value.length];
+                            this.insertText(userPath, userPath);
+                        }
+                        this.setAutoComplete(userPath, this.userEnteredPathSegment, i[0], true);
+                    }
+                });
+                this.filePickBox.onDidChangeValue(async (value) => {
+                    return this.handleValueChange(value);
+                });
+                this.filePickBox.onDidHide(() => {
+                    this.hidden = true;
+                    if (isResolving === 0) {
+                        doResolve(this, undefined);
+                    }
+                });
+                this.filePickBox.show();
+                this.contextKey.set(true);
+                this.updateItems(homedir, true, this.trailing).then(() => {
+                    if (this.trailing) {
+                        this.filePickBox.valueSelection = [this.filePickBox.value.length - this.trailing.length, this.filePickBox.value.length - ext.length];
+                    }
+                    else {
+                        this.filePickBox.valueSelection = [this.filePickBox.value.length, this.filePickBox.value.length];
+                    }
+                    this.busy = false;
+                });
+            }))
+        );
     }
     async handleValueChange(value) {
         try {
@@ -564,11 +549,7 @@ let SimpleFileDialog = class SimpleFileDialog {
                     return (await this.updateItems(valueUri)) ? UpdateResult.UpdatedWithTrailing : UpdateResult.Updated;
                 }
                 else if (this.endsWithSlash(value)) {
-                    this.filePickBox.validationMessage = ( localizeWithPath(
-                        'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                        'remoteFileDialog.badPath',
-                        'The path does not exist.'
-                    ));
+                    this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 6, 'The path does not exist.'));
                     this.badPath = value;
                     return UpdateResult.InvalidPath;
                 }
@@ -725,43 +706,37 @@ let SimpleFileDialog = class SimpleFileDialog {
         prompt.ignoreFocusOut = true;
         prompt.ok = true;
         prompt.customButton = true;
-        prompt.customLabel = ( localizeWithPath(
-            'vs/workbench/services/dialogs/browser/simpleFileDialog',
-            'remoteFileDialog.cancel',
-            'Cancel'
-        ));
+        prompt.customLabel = ( localizeWithPath(_moduleId, 7, 'Cancel'));
         prompt.value = this.pathFromUri(uri);
         let isResolving = false;
-        return ( new Promise(resolve => {
-            prompt.onDidAccept(() => {
-                isResolving = true;
-                prompt.hide();
-                resolve(true);
-            });
-            prompt.onDidHide(() => {
-                if (!isResolving) {
-                    resolve(false);
-                }
-                this.filePickBox.show();
-                this.hidden = false;
-                prompt.dispose();
-            });
-            prompt.onDidChangeValue(() => {
-                prompt.hide();
-            });
-            prompt.onDidCustom(() => {
-                prompt.hide();
-            });
-            prompt.show();
-        }));
+        return (
+             (new Promise(resolve => {
+                prompt.onDidAccept(() => {
+                    isResolving = true;
+                    prompt.hide();
+                    resolve(true);
+                });
+                prompt.onDidHide(() => {
+                    if (!isResolving) {
+                        resolve(false);
+                    }
+                    this.filePickBox.show();
+                    this.hidden = false;
+                    prompt.dispose();
+                });
+                prompt.onDidChangeValue(() => {
+                    prompt.hide();
+                });
+                prompt.onDidCustom(() => {
+                    prompt.hide();
+                });
+                prompt.show();
+            }))
+        );
     }
     async validate(uri) {
         if (uri === undefined) {
-            this.filePickBox.validationMessage = ( localizeWithPath(
-                'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                'remoteFileDialog.invalidPath',
-                'Please enter a valid path.'
-            ));
+            this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 8, 'Please enter a valid path.'));
             return Promise.resolve(false);
         }
         let stat;
@@ -774,51 +749,39 @@ let SimpleFileDialog = class SimpleFileDialog {
         }
         if (this.requiresTrailing) {
             if (stat && stat.isDirectory) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateFolder',
-                    'The folder already exists. Please use a new file name.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 9, 'The folder already exists. Please use a new file name.'));
                 return Promise.resolve(false);
             }
             else if (stat) {
                 const message = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateExisting',
+                    _moduleId,
+                    10,
                     '{0} already exists. Are you sure you want to overwrite it?',
                     basename(uri)
                 ));
                 return this.yesNoPrompt(uri, message);
             }
             else if (!(isValidBasename(basename(uri), this.isWindows))) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateBadFilename',
-                    'Please enter a valid file name.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 11, 'Please enter a valid file name.'));
                 return Promise.resolve(false);
             }
             else if (!statDirname) {
                 const message = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateCreateDirectory',
+                    _moduleId,
+                    12,
                     'The folder {0} does not exist. Would you like to create it?',
                     basename(dirname(uri))
                 ));
                 return this.yesNoPrompt(uri, message);
             }
             else if (!statDirname.isDirectory) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateNonexistentDir',
-                    'Please enter a path that exists.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 13, 'Please enter a path that exists.'));
                 return Promise.resolve(false);
             }
             else if (statDirname.readonly || statDirname.locked) {
                 this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateReadonlyFolder',
+                    _moduleId,
+                    14,
                     'This folder cannot be used as a save destination. Please choose another folder'
                 ));
                 return Promise.resolve(false);
@@ -826,35 +789,19 @@ let SimpleFileDialog = class SimpleFileDialog {
         }
         else {
             if (!stat) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateNonexistentDir',
-                    'Please enter a path that exists.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 13, 'Please enter a path that exists.'));
                 return Promise.resolve(false);
             }
             else if (uri.path === '/' && this.isWindows) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.windowsDriveLetter',
-                    'Please start the path with a drive letter.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 15, 'Please start the path with a drive letter.'));
                 return Promise.resolve(false);
             }
             else if (stat.isDirectory && !this.allowFolderSelection) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateFileOnly',
-                    'Please select a file.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 16, 'Please select a file.'));
                 return Promise.resolve(false);
             }
             else if (!stat.isDirectory && !this.allowFileSelection) {
-                this.filePickBox.validationMessage = ( localizeWithPath(
-                    'vs/workbench/services/dialogs/browser/simpleFileDialog',
-                    'remoteFileDialog.validateFolderOnly',
-                    'Please select a folder.'
-                ));
+                this.filePickBox.validationMessage = ( localizeWithPath(_moduleId, 17, 'Please select a folder.'));
                 return Promise.resolve(false);
             }
         }
@@ -965,7 +912,7 @@ let SimpleFileDialog = class SimpleFileDialog {
             if (!folder) {
                 folder = await this.fileService.resolve(currentFolder);
             }
-            const items = folder.children ? await Promise.all(( folder.children.map(child => this.createItem(child, currentFolder, token)))) : [];
+            const items = folder.children ? await Promise.all(( (folder.children.map(child => this.createItem(child, currentFolder, token))))) : [];
             for (const item of items) {
                 if (item) {
                     result.push(item);
@@ -1021,21 +968,21 @@ let SimpleFileDialog = class SimpleFileDialog {
         return undefined;
     }
 };
-SimpleFileDialog = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IQuickInputService)),
-    ( __param(2, ILabelService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IFileDialogService)),
-    ( __param(6, IModelService)),
-    ( __param(7, ILanguageService)),
-    ( __param(8, IWorkbenchEnvironmentService)),
-    ( __param(9, IRemoteAgentService)),
-    ( __param(10, IPathService)),
-    ( __param(11, IKeybindingService)),
-    ( __param(12, IContextKeyService)),
-    ( __param(13, IAccessibilityService))
-], SimpleFileDialog));
+SimpleFileDialog = ( (__decorate([
+    ( (__param(0, IFileService))),
+    ( (__param(1, IQuickInputService))),
+    ( (__param(2, ILabelService))),
+    ( (__param(3, IWorkspaceContextService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, IFileDialogService))),
+    ( (__param(6, IModelService))),
+    ( (__param(7, ILanguageService))),
+    ( (__param(8, IWorkbenchEnvironmentService))),
+    ( (__param(9, IRemoteAgentService))),
+    ( (__param(10, IPathService))),
+    ( (__param(11, IKeybindingService))),
+    ( (__param(12, IContextKeyService))),
+    ( (__param(13, IAccessibilityService)))
+], SimpleFileDialog)));
 export { OpenLocalFileCommand, OpenLocalFileFolderCommand, OpenLocalFolderCommand, RemoteFileDialogContext, SaveLocalFileCommand, SimpleFileDialog };

package/vscode/src/vs/workbench/services/dialogs/common/dialogService.js CHANGED Viewed

@@ -31,7 +31,9 @@ let DialogService = class DialogService extends Disposable {
     }
     async prompt(prompt) {
         if (this.skipDialogs()) {
-            throw new Error(`DialogService: refused to show dialog in tests. Contents: ${prompt.message}`);
+            throw ( new Error(
+                `DialogService: refused to show dialog in tests. Contents: ${prompt.message}`
+            ));
         }
         const handle = this.model.show({ promptArgs: { prompt } });
         const dialogResult = await handle.result;
@@ -42,7 +44,7 @@ let DialogService = class DialogService extends Disposable {
     }
     async input(input) {
         if (this.skipDialogs()) {
-            throw new Error('DialogService: refused to show input dialog in tests.');
+            throw ( new Error('DialogService: refused to show input dialog in tests.'));
         }
         const handle = this.model.show({ inputArgs: { input } });
         return await handle.result;
@@ -58,7 +60,7 @@ let DialogService = class DialogService extends Disposable {
     }
     async about() {
         if (this.skipDialogs()) {
-            throw new Error('DialogService: refused to show about dialog in tests.');
+            throw ( new Error('DialogService: refused to show about dialog in tests.'));
         }
         const handle = this.model.show({});
         await handle.result;

package/dialogs.d.ts DELETED Viewed

@@ -1,12 +0,0 @@
-import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-interface DialogServiceOverrideProps {
-    /**
-     * Is an `HTMLFileSystemProvider` is used as only provider for the `file` scheme directly (without overlay)
-     * Enable this option to enable browser file dialogs
-     */
-    useHtmlFileSystemProvider?: boolean;
-}
-declare function getServiceOverride({ useHtmlFileSystemProvider }?: DialogServiceOverrideProps): IEditorOverrideServices;
-export { getServiceOverride as default };