@codingame/monaco-vscode-localization-service-override 4.1.0

package/vscode/src/vs/workbench/contrib/userDataProfile/browser/userDataProfileActions.js

@@ -0,0 +1,197 @@
+import { Separator } from 'vscode/vscode/vs/base/common/actions';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { Action2, registerAction2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+import { PROFILES_CATEGORY, PROFILES_ENABLEMENT_CONTEXT, IUserDataProfileManagementService, HAS_PROFILES_CONTEXT, IUserDataProfileService, MANAGE_PROFILES_ACTION_ID, ProfilesMenu } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+class CreateTransientProfileAction extends Action2 {
+    static { this.ID = 'workbench.profiles.actions.createTemporaryProfile'; }
+    static { this.TITLE = ( localize2WithPath(
+        'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+        'create temporary profile',
+        "Create a Temporary Profile"
+    )); }
+    constructor() {
+        super({
+            id: CreateTransientProfileAction.ID,
+            title: CreateTransientProfileAction.TITLE,
+            category: PROFILES_CATEGORY,
+            f1: true,
+            precondition: PROFILES_ENABLEMENT_CONTEXT,
+        });
+    }
+    async run(accessor) {
+        return accessor.get(IUserDataProfileManagementService).createAndEnterTransientProfile();
+    }
+}
+registerAction2(CreateTransientProfileAction);
+class RenameProfileAction extends Action2 {
+    static { this.ID = 'workbench.profiles.actions.renameProfile'; }
+    constructor() {
+        super({
+            id: RenameProfileAction.ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'rename profile',
+                "Rename..."
+            )),
+            category: PROFILES_CATEGORY,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(PROFILES_ENABLEMENT_CONTEXT, HAS_PROFILES_CONTEXT)),
+        });
+    }
+    async run(accessor, profile) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const userDataProfileService = accessor.get(IUserDataProfileService);
+        const userDataProfilesService = accessor.get(IUserDataProfilesService);
+        const userDataProfileManagementService = accessor.get(IUserDataProfileManagementService);
+        const notificationService = accessor.get(INotificationService);
+        if (!profile) {
+            profile = await this.pickProfile(quickInputService, userDataProfileService, userDataProfilesService);
+        }
+        if (!profile || profile.isDefault) {
+            return;
+        }
+        const name = await quickInputService.input({
+            value: profile.name,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'select profile to rename',
+                'Rename {0}',
+                profile.name
+            )),
+            validateInput: async (value) => {
+                if (profile.name !== value && ( userDataProfilesService.profiles.some(p => p.name === value))) {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                        'profileExists',
+                        "Profile with name {0} already exists.",
+                        value
+                    ));
+                }
+                return undefined;
+            }
+        });
+        if (name && name !== profile.name) {
+            try {
+                await userDataProfileManagementService.updateProfile(profile, { name });
+            }
+            catch (error) {
+                notificationService.error(error);
+            }
+        }
+    }
+    async pickProfile(quickInputService, userDataProfileService, userDataProfilesService) {
+        const profiles = userDataProfilesService.profiles.filter(p => !p.isDefault && !p.isTransient);
+        if (!profiles.length) {
+            return undefined;
+        }
+        const pick = await quickInputService.pick(( profiles.map(profile => ({
+            label: profile.name,
+            description: profile.id === userDataProfileService.currentProfile.id ? ( localizeWithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'current',
+                "Current"
+            )) : undefined,
+            profile
+        }))), {
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'rename specific profile',
+                "Rename Profile..."
+            )),
+            placeHolder: ( localizeWithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'pick profile to rename',
+                "Select Profile to Rename"
+            )),
+        });
+        return pick?.profile;
+    }
+}
+registerAction2(RenameProfileAction);
+registerAction2(class ManageProfilesAction extends Action2 {
+    constructor() {
+        super({
+            id: MANAGE_PROFILES_ACTION_ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'mange',
+                "Manage..."
+            )),
+            category: PROFILES_CATEGORY,
+            precondition: ( ContextKeyExpr.and(PROFILES_ENABLEMENT_CONTEXT, HAS_PROFILES_CONTEXT)),
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const menuService = accessor.get(IMenuService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        const commandService = accessor.get(ICommandService);
+        const menu = menuService.createMenu(ProfilesMenu, contextKeyService);
+        const actions = [];
+        createAndFillInActionBarActions(menu, undefined, actions);
+        menu.dispose();
+        if (actions.length) {
+            const picks = ( actions.map(action => {
+                if (action instanceof Separator) {
+                    return { type: 'separator' };
+                }
+                return {
+                    id: action.id,
+                    label: `${action.label}${action.checked ? ` $(${Codicon.check.id})` : ''}`,
+                };
+            }));
+            const pick = await quickInputService.pick(picks, { canPickMany: false, title: PROFILES_CATEGORY.value });
+            if (pick?.id) {
+                await commandService.executeCommand(pick.id);
+            }
+        }
+    }
+});
+registerAction2(class CleanupProfilesAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.profiles.actions.cleanupProfiles',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'cleanup profile',
+                "Cleanup Profiles"
+            )),
+            category: Categories.Developer,
+            f1: true,
+            precondition: PROFILES_ENABLEMENT_CONTEXT,
+        });
+    }
+    async run(accessor) {
+        return accessor.get(IUserDataProfilesService).cleanUp();
+    }
+});
+registerAction2(class ResetWorkspacesAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.profiles.actions.resetWorkspaces',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/userDataProfile/browser/userDataProfileActions',
+                'reset workspaces',
+                "Reset Workspace Profiles Associations"
+            )),
+            category: Categories.Developer,
+            f1: true,
+            precondition: PROFILES_ENABLEMENT_CONTEXT,
+        });
+    }
+    async run(accessor) {
+        const userDataProfilesService = accessor.get(IUserDataProfilesService);
+        return userDataProfilesService.resetWorkspaces();
+    }
+});
+
+export { RenameProfileAction };

package/vscode/src/vs/workbench/contrib/userDataProfile/browser/userDataProfilePreview.js

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getErrorMessage } from 'vscode/vscode/vs/base/common/errors';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let UserDataProfilePreviewContribution = class UserDataProfilePreviewContribution extends Disposable {
+    constructor(environmentService, userDataProfileImportExportService, logService) {
+        super();
+        if (environmentService.options?.profileToPreview) {
+            userDataProfileImportExportService.importProfile(URI.revive(environmentService.options.profileToPreview), { mode: 'both' })
+                .then(null, error => logService.error('Error while previewing the profile', getErrorMessage(error)));
+        }
+    }
+};
+UserDataProfilePreviewContribution = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, IUserDataProfileImportExportService)),
+    ( __param(2, ILogService))
+], UserDataProfilePreviewContribution));
+
+export { UserDataProfilePreviewContribution };

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

@@ -0,0 +1,244 @@
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { AbstractFileDialogService } from 'vscode/vscode/vs/workbench/services/dialogs/browser/abstractFileDialogService';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { getMediaOrTextMime } from 'vscode/vscode/vs/base/common/mime';
+import { basename } from 'vscode/vscode/vs/base/common/resources';
+import { getActiveWindow, triggerDownload, triggerUpload } from 'vscode/vscode/vs/base/browser/dom';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { extractFileListData } from 'vscode/vscode/vs/platform/dnd/browser/dnd';
+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';
+
+class FileDialogService extends AbstractFileDialogService {
+    get fileSystemProvider() {
+        return this.fileService.getProvider(Schemas.file);
+    }
+    async pickFileFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        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."));
+    }
+    addFileSchemaIfNeeded(schema, isFolder) {
+        return (schema === Schemas.untitled) ? [Schemas.file]
+            : (((schema !== Schemas.file) && (!isFolder || (schema !== Schemas.vscodeRemote))) ? [schema, Schemas.file] : [schema]);
+    }
+    async pickFileAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFileAndOpenSimplified(schema, options, false);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('open');
+        }
+        let fileHandle = undefined;
+        try {
+            ([fileHandle] = await activeWindow.showOpenFilePicker({ multiple: false }));
+        }
+        catch (error) {
+            return;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return;
+        }
+        const uri = await this.fileSystemProvider.registerFileHandle(fileHandle);
+        this.addFileToRecentlyOpened(uri);
+        await this.openerService.open(uri, { fromUserGesture: true, editorOptions: { pinned: true } });
+    }
+    async pickFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFolderPath(schema);
+        }
+        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."));
+    }
+    async pickWorkspaceAndOpen(options) {
+        options.availableFileSystems = this.getWorkspaceAvailableFileSystems(options);
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultWorkspacePath(schema);
+        }
+        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."));
+    }
+    async pickFileToSave(defaultUri, availableFileSystems) {
+        const schema = this.getFileSystemSchema({ defaultUri, availableFileSystems });
+        const options = this.getPickFileToSaveDialogOptions(defaultUri, availableFileSystems);
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFileToSaveSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('save');
+        }
+        let fileHandle = undefined;
+        const startIn = Iterable.first(this.fileSystemProvider.directories);
+        try {
+            fileHandle = await activeWindow.showSaveFilePicker({ types: this.getFilePickerTypes(options.filters), ...{ suggestedName: basename(defaultUri), startIn } });
+        }
+        catch (error) {
+            return;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return undefined;
+        }
+        return this.fileSystemProvider.registerFileHandle(fileHandle);
+    }
+    getFilePickerTypes(filters) {
+        return filters?.filter(filter => {
+            return !((filter.extensions.length === 1) && ((filter.extensions[0] === '*') || filter.extensions[0] === ''));
+        }).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}`));
+            return {
+                description: filter.name,
+                accept
+            };
+        });
+    }
+    async showSaveDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (this.shouldUseSimplified(schema)) {
+            return super.showSaveDialogSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('save');
+        }
+        let fileHandle = undefined;
+        const startIn = Iterable.first(this.fileSystemProvider.directories);
+        try {
+            fileHandle = await activeWindow.showSaveFilePicker({ types: this.getFilePickerTypes(options.filters), ...(options.defaultUri ? { suggestedName: basename(options.defaultUri) } : undefined), ...{ startIn } });
+        }
+        catch (error) {
+            return undefined;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return undefined;
+        }
+        return this.fileSystemProvider.registerFileHandle(fileHandle);
+    }
+    async showOpenDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (this.shouldUseSimplified(schema)) {
+            return super.showOpenDialogSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('open');
+        }
+        let uri;
+        const startIn = Iterable.first(this.fileSystemProvider.directories) ?? 'documents';
+        try {
+            if (options.canSelectFiles) {
+                const handle = await activeWindow.showOpenFilePicker({ multiple: false, types: this.getFilePickerTypes(options.filters), ...{ startIn } });
+                if (handle.length === 1 && WebFileSystemAccess.isFileSystemFileHandle(handle[0])) {
+                    uri = await this.fileSystemProvider.registerFileHandle(handle[0]);
+                }
+            }
+            else {
+                const handle = await activeWindow.showDirectoryPicker({ ...{ startIn } });
+                uri = await this.fileSystemProvider.registerDirectoryHandle(handle);
+            }
+        }
+        catch (error) {
+        }
+        return uri ? [uri] : undefined;
+    }
+    async showUnsupportedBrowserWarning(context) {
+        if (context === 'save') {
+            const activeCodeEditor = this.codeEditorService.getActiveCodeEditor();
+            if (!(activeCodeEditor instanceof EmbeddedCodeEditorWidget)) {
+                const activeTextModel = activeCodeEditor?.getModel();
+                if (activeTextModel) {
+                    triggerDownload(VSBuffer.fromString(activeTextModel.getValue()).buffer, basename(activeTextModel.uri));
+                    return;
+                }
+            }
+        }
+        const buttons = [
+            {
+                label: ( localizeWithPath(
+                    'vs/workbench/services/dialogs/browser/fileDialogService',
+                    { key: 'openRemote', comment: ['&& denotes a mnemonic'] },
+                    "&&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"
+                )),
+                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..."
+                )),
+                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 => {
+                                return {
+                                    resource: fileData.resource,
+                                    contents: fileData.contents?.toString(),
+                                    options: { pinned: true }
+                                };
+                            })));
+                        }
+                    }
+                }
+            });
+        }
+        await this.dialogService.prompt({
+            type: Severity$1.Warning,
+            message: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/fileDialogService',
+                'unsupportedBrowserMessage',
+                "Opening Local Folders is Unsupported"
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/fileDialogService',
+                'unsupportedBrowserDetail',
+                "Your browser doesn't support opening local folders.\nYou can either open single files or open a remote repository."
+            )),
+            buttons
+        });
+        return undefined;
+    }
+    shouldUseSimplified(scheme) {
+        return ![Schemas.file, Schemas.vscodeUserData, Schemas.tmp].includes(scheme);
+    }
+}
+FileDialogService.__decorator = ( __decorate([
+    memoize
+], FileDialogService.prototype, "fileSystemProvider", null));
+
+export { FileDialogService };