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

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

@@ -0,0 +1,379 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { isWorkspaceToOpen, isFileToOpen } from 'vscode/vscode/vs/platform/window/common/window';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { isSavedWorkspace, isTemporaryWorkspace, WORKSPACE_EXTENSION, IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { dirname, toLocalResource, basename, extname } from 'vscode/vscode/vs/base/common/resources';
+import { isAbsolute, normalize } from 'vscode/vscode/vs/base/common/path';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { SimpleFileDialog } from './simpleFileDialog.js';
+import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { coalesce, distinct } from 'vscode/vscode/vs/base/common/arrays';
+import { trim } from 'vscode/vscode/vs/base/common/strings';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { PLAINTEXT_EXTENSION } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { EditorOpenSource } from 'vscode/vscode/vs/platform/editor/common/editor';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { getFileNamesMessage, IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+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;
+        this.contextService = contextService;
+        this.historyService = historyService;
+        this.environmentService = environmentService;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.fileService = fileService;
+        this.openerService = openerService;
+        this.dialogService = dialogService;
+        this.languageService = languageService;
+        this.workspacesService = workspacesService;
+        this.labelService = labelService;
+        this.pathService = pathService;
+        this.commandService = commandService;
+        this.editorService = editorService;
+        this.codeEditorService = codeEditorService;
+        this.logService = logService;
+    }
+    async defaultFilePath(schemeFilter = this.getSchemeFilterForWindow(), authorityFilter = this.getAuthorityFilterForWindow()) {
+        let candidate = this.historyService.getLastActiveFile(schemeFilter, authorityFilter);
+        if (!candidate) {
+            candidate = this.historyService.getLastActiveWorkspaceRoot(schemeFilter, authorityFilter);
+        }
+        else {
+            candidate = dirname(candidate);
+        }
+        if (!candidate) {
+            candidate = await this.preferredHome(schemeFilter);
+        }
+        return candidate;
+    }
+    async defaultFolderPath(schemeFilter = this.getSchemeFilterForWindow(), authorityFilter = this.getAuthorityFilterForWindow()) {
+        let candidate = this.historyService.getLastActiveWorkspaceRoot(schemeFilter, authorityFilter);
+        if (!candidate) {
+            candidate = this.historyService.getLastActiveFile(schemeFilter, authorityFilter);
+        }
+        if (!candidate) {
+            return this.preferredHome(schemeFilter);
+        }
+        return dirname(candidate);
+    }
+    async preferredHome(schemeFilter = this.getSchemeFilterForWindow()) {
+        const preferLocal = schemeFilter === Schemas.file;
+        const preferredHomeConfig = this.configurationService.inspect('files.dialog.defaultPath');
+        const preferredHomeCandidate = preferLocal ? preferredHomeConfig.userLocalValue : preferredHomeConfig.userRemoteValue;
+        if (preferredHomeCandidate) {
+            const isPreferredHomeCandidateAbsolute = preferLocal ? isAbsolute(preferredHomeCandidate) : (await this.pathService.path).isAbsolute(preferredHomeCandidate);
+            if (isPreferredHomeCandidateAbsolute) {
+                const preferredHomeNormalized = preferLocal ? normalize(preferredHomeCandidate) : (await this.pathService.path).normalize(preferredHomeCandidate);
+                const preferredHome = toLocalResource(await this.pathService.fileURI(preferredHomeNormalized), this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+                if (await this.fileService.exists(preferredHome)) {
+                    return preferredHome;
+                }
+            }
+        }
+        return this.pathService.userHome({ preferLocal });
+    }
+    async defaultWorkspacePath(schemeFilter = this.getSchemeFilterForWindow()) {
+        let defaultWorkspacePath;
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            const configuration = this.contextService.getWorkspace().configuration;
+            if (configuration?.scheme === schemeFilter && isSavedWorkspace(configuration, this.environmentService) && !isTemporaryWorkspace(configuration)) {
+                defaultWorkspacePath = dirname(configuration);
+            }
+        }
+        if (!defaultWorkspacePath) {
+            defaultWorkspacePath = await this.defaultFilePath(schemeFilter);
+        }
+        return defaultWorkspacePath;
+    }
+    async showSaveConfirm(fileNamesOrResources) {
+        if (this.skipDialogs()) {
+            this.logService.trace('FileDialogService: refused to show save confirmation dialog in tests.');
+            return 1 ;
+        }
+        return this.doShowSaveConfirm(fileNamesOrResources);
+    }
+    skipDialogs() {
+        if (this.environmentService.isExtensionDevelopment && this.environmentService.extensionTestsLocationURI) {
+            return true;
+        }
+        return !!this.environmentService.enableSmokeTestDriver;
+    }
+    async doShowSaveConfirm(fileNamesOrResources) {
+        if (fileNamesOrResources.length === 0) {
+            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."
+        ));
+        if (fileNamesOrResources.length === 1) {
+            message = ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+                'saveChangesMessage',
+                "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',
+                "Do you want to save the changes to the following {0} files?",
+                fileNamesOrResources.length
+            ));
+            detail = getFileNamesMessage(fileNamesOrResources) + '\n' + detail;
+        }
+        const { result } = await this.dialogService.prompt({
+            type: Severity$1.Warning,
+            message,
+            detail,
+            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"
+                        )),
+                    run: () => 0
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+                        { key: 'dontSave', comment: ['&& denotes a mnemonic'] },
+                        "Do&&n't Save"
+                    )),
+                    run: () => 1
+                }
+            ],
+            cancelButton: {
+                run: () => 2
+            }
+        });
+        return result;
+    }
+    addFileSchemaIfNeeded(schema, _isFolder) {
+        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 availableFileSystems = this.addFileSchemaIfNeeded(schema);
+        const uri = await this.pickResource({ canSelectFiles: true, canSelectFolders: true, canSelectMany: false, defaultUri: options.defaultUri, title, availableFileSystems });
+        if (uri) {
+            const stat = await this.fileService.stat(uri);
+            const toOpen = stat.isDirectory ? { folderUri: uri } : { fileUri: uri };
+            if (!isWorkspaceToOpen(toOpen) && isFileToOpen(toOpen)) {
+                this.addFileToRecentlyOpened(toOpen.fileUri);
+            }
+            if (stat.isDirectory || options.forceNewWindow || preferNewWindow) {
+                await this.hostService.openWindow([toOpen], { forceNewWindow: options.forceNewWindow, remoteAuthority: options.remoteAuthority });
+            }
+            else {
+                await this.editorService.openEditors([{ resource: uri, options: { source: EditorOpenSource.USER, pinned: true } }], undefined, { validateTrust: true });
+            }
+        }
+    }
+    async pickFileAndOpenSimplified(schema, options, preferNewWindow) {
+        const title = ( localizeWithPath(
+            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+            'openFile.title',
+            '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) {
+            this.addFileToRecentlyOpened(uri);
+            if (options.forceNewWindow || preferNewWindow) {
+                await this.hostService.openWindow([{ fileUri: uri }], { forceNewWindow: options.forceNewWindow, remoteAuthority: options.remoteAuthority });
+            }
+            else {
+                await this.editorService.openEditors([{ resource: uri, options: { source: EditorOpenSource.USER, pinned: true } }], undefined, { validateTrust: true });
+            }
+        }
+    }
+    addFileToRecentlyOpened(uri) {
+        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 availableFileSystems = this.addFileSchemaIfNeeded(schema, true);
+        const uri = await this.pickResource({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, defaultUri: options.defaultUri, title, availableFileSystems });
+        if (uri) {
+            return this.hostService.openWindow([{ folderUri: uri }], { forceNewWindow: options.forceNewWindow, remoteAuthority: options.remoteAuthority });
+        }
+    }
+    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 availableFileSystems = this.addFileSchemaIfNeeded(schema, true);
+        const uri = await this.pickResource({ canSelectFiles: true, canSelectFolders: false, canSelectMany: false, defaultUri: options.defaultUri, title, filters, availableFileSystems });
+        if (uri) {
+            return this.hostService.openWindow([{ workspaceUri: uri }], { forceNewWindow: options.forceNewWindow, remoteAuthority: options.remoteAuthority });
+        }
+    }
+    async pickFileToSaveSimplified(schema, options) {
+        if (!options.availableFileSystems) {
+            options.availableFileSystems = this.addFileSchemaIfNeeded(schema);
+        }
+        options.title = ( localizeWithPath(
+            'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+            'saveFileAs.title',
+            'Save As'
+        ));
+        const uri = await this.saveRemoteResource(options);
+        if (uri) {
+            this.addFileToRecentlyOpened(uri);
+        }
+        return uri;
+    }
+    async showSaveDialogSimplified(schema, options) {
+        if (!options.availableFileSystems) {
+            options.availableFileSystems = this.addFileSchemaIfNeeded(schema);
+        }
+        return this.saveRemoteResource(options);
+    }
+    async showOpenDialogSimplified(schema, options) {
+        if (!options.availableFileSystems) {
+            options.availableFileSystems = this.addFileSchemaIfNeeded(schema, options.canSelectFolders);
+        }
+        const uri = await this.pickResource(options);
+        return uri ? [uri] : undefined;
+    }
+    getSimpleFileDialog() {
+        return this.instantiationService.createInstance(SimpleFileDialog);
+    }
+    pickResource(options) {
+        return this.getSimpleFileDialog().showOpenDialog(options);
+    }
+    saveRemoteResource(options) {
+        return this.getSimpleFileDialog().showSaveDialog(options);
+    }
+    getSchemeFilterForWindow(defaultUriScheme) {
+        return defaultUriScheme ?? this.pathService.defaultUriScheme;
+    }
+    getAuthorityFilterForWindow() {
+        return this.environmentService.remoteAuthority;
+    }
+    getFileSystemSchema(options) {
+        return options.availableFileSystems && options.availableFileSystems[0] || this.getSchemeFilterForWindow(options.defaultUri?.scheme);
+    }
+    getWorkspaceAvailableFileSystems(options) {
+        if (options.availableFileSystems && (options.availableFileSystems.length > 0)) {
+            return options.availableFileSystems;
+        }
+        const availableFileSystems = [Schemas.file];
+        if (this.environmentService.remoteAuthority) {
+            availableFileSystems.unshift(Schemas.vscodeRemote);
+        }
+        return availableFileSystems;
+    }
+    getPickFileToSaveDialogOptions(defaultUri, availableFileSystems) {
+        const options = {
+            defaultUri,
+            title: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+                'saveAsTitle',
+                "Save As"
+            )),
+            availableFileSystems
+        };
+        const ext = defaultUri ? extname(defaultUri) : undefined;
+        let matchingFilter;
+        const registeredLanguageNames = this.languageService.getSortedRegisteredLanguageNames();
+        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 extOrPlaintext = ext || PLAINTEXT_EXTENSION;
+            if (!matchingFilter && extensions.includes(extOrPlaintext)) {
+                matchingFilter = filter;
+                const trimmedExt = trim(extOrPlaintext, '.');
+                if (!filter.extensions.includes(trimmedExt)) {
+                    filter.extensions.unshift(trimmedExt);
+                }
+                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: ['*'] },
+            matchingFilter,
+            ...registeredLanguageFilters,
+            { name: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/abstractFileDialogService',
+                'noExt',
+                "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));
+
+export { AbstractFileDialogService };