@codingame/monaco-vscode-user-data-profile-service-override 5.3.0

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

@@ -0,0 +1,495 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { MenuRegistry, MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { CURRENT_PROFILE_CONTEXT, PROFILES_ENABLEMENT_CONTEXT, IS_CURRENT_PROFILE_TRANSIENT_CONTEXT, HAS_PROFILES_CONTEXT, ProfilesMenu, PROFILES_CATEGORY, IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, PROFILE_FILTER, PROFILES_TITLE } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IUserDataProfileImportExportService, IUserDataProfileService, IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkspaceTagsService } from 'vscode/vscode/vs/workbench/contrib/tags/common/workspaceTags.service';
+import { getErrorMessage } from 'vscode/vscode/vs/base/common/errors';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+
+const _moduleId = "vs/workbench/contrib/userDataProfile/browser/userDataProfile";
+let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.userDataProfiles'; }
+    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, userDataProfileImportExportService, telemetryService, workspaceContextService, workspaceTagsService, contextKeyService, lifecycleService) {
+        super();
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileManagementService = userDataProfileManagementService;
+        this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this.telemetryService = telemetryService;
+        this.workspaceContextService = workspaceContextService;
+        this.workspaceTagsService = workspaceTagsService;
+        this.lifecycleService = lifecycleService;
+        this.profilesDisposable = this._register(( (new MutableDisposable())));
+        this.currentprofileActionsDisposable = this._register(( (new MutableDisposable())));
+        this.currentProfileContext = CURRENT_PROFILE_CONTEXT.bindTo(contextKeyService);
+        PROFILES_ENABLEMENT_CONTEXT.bindTo(contextKeyService).set(this.userDataProfilesService.isEnabled());
+        this.isCurrentProfileTransientContext = IS_CURRENT_PROFILE_TRANSIENT_CONTEXT.bindTo(contextKeyService);
+        this.currentProfileContext.set(this.userDataProfileService.currentProfile.id);
+        this.isCurrentProfileTransientContext.set(!!this.userDataProfileService.currentProfile.isTransient);
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => {
+            this.currentProfileContext.set(this.userDataProfileService.currentProfile.id);
+            this.isCurrentProfileTransientContext.set(!!this.userDataProfileService.currentProfile.isTransient);
+        }));
+        this.hasProfilesContext = HAS_PROFILES_CONTEXT.bindTo(contextKeyService);
+        this.hasProfilesContext.set(this.userDataProfilesService.profiles.length > 1);
+        this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.hasProfilesContext.set(this.userDataProfilesService.profiles.length > 1)));
+        this.registerActions();
+        if (isWeb) {
+            lifecycleService.when(4 ).then(() => userDataProfilesService.cleanUp());
+        }
+        this.reportWorkspaceProfileInfo();
+    }
+    registerActions() {
+        this.registerProfileSubMenu();
+        this._register(this.registerSwitchProfileAction());
+        this.registerProfilesActions();
+        this._register(this.userDataProfilesService.onDidChangeProfiles(() => this.registerProfilesActions()));
+        this.registerCurrentProfilesActions();
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => this.registerCurrentProfilesActions()));
+        this.registerCreateFromCurrentProfileAction();
+        this.registerCreateProfileAction();
+        this.registerDeleteProfileAction();
+        this.registerHelpAction();
+    }
+    registerProfileSubMenu() {
+        const getProfilesTitle = () => {
+            return ( localizeWithPath(
+                _moduleId,
+                0,
+                "Profiles ({0})",
+                this.userDataProfileService.currentProfile.name
+            ));
+        };
+        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+            get title() {
+                return getProfilesTitle();
+            },
+            submenu: ProfilesMenu,
+            group: '2_configuration',
+            order: 1,
+        });
+        MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+            get title() {
+                return getProfilesTitle();
+            },
+            submenu: ProfilesMenu,
+            group: '2_configuration',
+            order: 1,
+            when: PROFILES_ENABLEMENT_CONTEXT,
+        });
+    }
+    registerProfilesActions() {
+        this.profilesDisposable.value = ( (new DisposableStore()));
+        for (const profile of this.userDataProfilesService.profiles) {
+            this.profilesDisposable.value.add(this.registerProfileEntryAction(profile));
+        }
+    }
+    registerProfileEntryAction(profile) {
+        const that = this;
+        return registerAction2(class ProfileEntryAction extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.profiles.actions.profileEntry.${profile.id}`,
+                    title: profile.name,
+                    toggled: ( (ContextKeyExpr.equals(CURRENT_PROFILE_CONTEXT.key, profile.id))),
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '0_profiles',
+                            when: PROFILES_ENABLEMENT_CONTEXT,
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                if (that.userDataProfileService.currentProfile.id !== profile.id) {
+                    return that.userDataProfileManagementService.switchProfile(profile);
+                }
+            }
+        });
+    }
+    registerSwitchProfileAction() {
+        return registerAction2(class SwitchProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.profiles.actions.switchProfile`,
+                    title: ( localize2WithPath(_moduleId, 1, 'Switch Profile...')),
+                    category: PROFILES_CATEGORY,
+                    f1: true,
+                    precondition: PROFILES_ENABLEMENT_CONTEXT,
+                });
+            }
+            async run(accessor) {
+                const quickInputService = accessor.get(IQuickInputService);
+                const menuService = accessor.get(IMenuService);
+                const menu = menuService.createMenu(ProfilesMenu, accessor.get(IContextKeyService));
+                const actions = menu.getActions().find(([group]) => group === '0_profiles')?.[1] ?? [];
+                try {
+                    const result = await quickInputService.pick(( (actions.map(action => ({
+                        action,
+                        label: action.checked ? `$(check) ${action.label}` : action.label,
+                    })))), {
+                        placeHolder: ( localizeWithPath(_moduleId, 2, "Select Profile"))
+                    });
+                    await result?.action.run();
+                }
+                finally {
+                    menu.dispose();
+                }
+            }
+        });
+    }
+    registerCurrentProfilesActions() {
+        this.currentprofileActionsDisposable.value = ( (new DisposableStore()));
+        this.currentprofileActionsDisposable.value.add(this.registerEditCurrentProfileAction());
+        this.currentprofileActionsDisposable.value.add(this.registerShowCurrentProfileContentsAction());
+        this.currentprofileActionsDisposable.value.add(this.registerExportCurrentProfileAction());
+        this.currentprofileActionsDisposable.value.add(this.registerImportProfileAction());
+    }
+    registerEditCurrentProfileAction() {
+        const that = this;
+        return registerAction2(class RenameCurrentProfileAction extends Action2 {
+            constructor() {
+                const when = ( (ContextKeyExpr.and( (ContextKeyExpr.notEquals(
+                    CURRENT_PROFILE_CONTEXT.key,
+                    that.userDataProfilesService.defaultProfile.id
+                )),  (IS_CURRENT_PROFILE_TRANSIENT_CONTEXT.toNegated()))));
+                super({
+                    id: `workbench.profiles.actions.editCurrentProfile`,
+                    title: ( localize2WithPath(_moduleId, 3, "Edit Profile...")),
+                    precondition: when,
+                    f1: true,
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '2_manage_current',
+                            when,
+                            order: 2
+                        }
+                    ]
+                });
+            }
+            run() {
+                return that.userDataProfileImportExportService.editProfile(that.userDataProfileService.currentProfile);
+            }
+        });
+    }
+    registerShowCurrentProfileContentsAction() {
+        const id = 'workbench.profiles.actions.showProfileContents';
+        return registerAction2(class ShowProfileContentsAction extends Action2 {
+            constructor() {
+                super({
+                    id,
+                    title: ( localize2WithPath(_moduleId, 4, "Show Profile Contents")),
+                    category: PROFILES_CATEGORY,
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '2_manage_current',
+                            order: 3
+                        }, {
+                            id: MenuId.CommandPalette
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                const userDataProfileImportExportService = accessor.get(IUserDataProfileImportExportService);
+                return userDataProfileImportExportService.showProfileContents();
+            }
+        });
+    }
+    registerExportCurrentProfileAction() {
+        const that = this;
+        const disposables = ( (new DisposableStore()));
+        const id = 'workbench.profiles.actions.exportProfile';
+        disposables.add(registerAction2(class ExportProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id,
+                    title: ( localize2WithPath(_moduleId, 5, "Export Profile...")),
+                    category: PROFILES_CATEGORY,
+                    precondition: ( (IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT.toNegated())),
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '4_import_export_profiles',
+                            order: 1
+                        }, {
+                            id: MenuId.CommandPalette
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                const userDataProfileImportExportService = accessor.get(IUserDataProfileImportExportService);
+                return userDataProfileImportExportService.exportProfile();
+            }
+        }));
+        disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarShare, {
+            command: {
+                id,
+                title: ( localize2WithPath(
+                    _moduleId,
+                    6,
+                    "Export Profile ({0})...",
+                    that.userDataProfileService.currentProfile.name
+                )),
+                precondition: PROFILES_ENABLEMENT_CONTEXT,
+            },
+        }));
+        return disposables;
+    }
+    registerImportProfileAction() {
+        const disposables = ( (new DisposableStore()));
+        const id = 'workbench.profiles.actions.importProfile';
+        const that = this;
+        disposables.add(registerAction2(class ImportProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id,
+                    title: ( localize2WithPath(_moduleId, 7, "Import Profile...")),
+                    category: PROFILES_CATEGORY,
+                    precondition: ( (IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT.toNegated())),
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '4_import_export_profiles',
+                            when: PROFILES_ENABLEMENT_CONTEXT,
+                            order: 2
+                        }, {
+                            id: MenuId.CommandPalette,
+                            when: PROFILES_ENABLEMENT_CONTEXT,
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                const fileDialogService = accessor.get(IFileDialogService);
+                const quickInputService = accessor.get(IQuickInputService);
+                const userDataProfileImportExportService = accessor.get(IUserDataProfileImportExportService);
+                const notificationService = accessor.get(INotificationService);
+                const disposables = ( (new DisposableStore()));
+                const quickPick = disposables.add(quickInputService.createQuickPick());
+                const profileTemplateQuickPickItems = await that.getProfileTemplatesQuickPickItems();
+                const updateQuickPickItems = (value) => {
+                    const quickPickItems = [];
+                    if (value) {
+                        quickPickItems.push({ label: quickPick.value, description: ( localizeWithPath(_moduleId, 8, "Import from URL")) });
+                    }
+                    quickPickItems.push({ label: ( localizeWithPath(_moduleId, 9, "Select File...")) });
+                    if (profileTemplateQuickPickItems.length) {
+                        quickPickItems.push({
+                            type: 'separator',
+                            label: ( localizeWithPath(_moduleId, 10, "Profile Templates"))
+                        }, ...profileTemplateQuickPickItems);
+                    }
+                    quickPick.items = quickPickItems;
+                };
+                quickPick.title = ( localizeWithPath(_moduleId, 11, "Import from Profile Template..."));
+                quickPick.placeholder = ( localizeWithPath(_moduleId, 12, "Provide Profile Template URL"));
+                quickPick.ignoreFocusOut = true;
+                disposables.add(quickPick.onDidChangeValue(updateQuickPickItems));
+                updateQuickPickItems();
+                quickPick.matchOnLabel = false;
+                quickPick.matchOnDescription = false;
+                disposables.add(quickPick.onDidAccept(async () => {
+                    quickPick.hide();
+                    const selectedItem = quickPick.selectedItems[0];
+                    if (!selectedItem) {
+                        return;
+                    }
+                    try {
+                        if (selectedItem.url) {
+                            return await that.userDataProfileImportExportService.createProfile(( (URI.parse(selectedItem.url))));
+                        }
+                        const profile = selectedItem.label === quickPick.value ? ( (URI.parse(quickPick.value))) : await this.getProfileUriFromFileSystem(fileDialogService);
+                        if (profile) {
+                            await userDataProfileImportExportService.importProfile(profile);
+                        }
+                    }
+                    catch (error) {
+                        notificationService.error(( localizeWithPath(_moduleId, 13, "Error while creating profile: {0}", getErrorMessage(error))));
+                    }
+                }));
+                disposables.add(quickPick.onDidHide(() => disposables.dispose()));
+                quickPick.show();
+            }
+            async getProfileUriFromFileSystem(fileDialogService) {
+                const profileLocation = await fileDialogService.showOpenDialog({
+                    canSelectFolders: false,
+                    canSelectFiles: true,
+                    canSelectMany: false,
+                    filters: PROFILE_FILTER,
+                    title: ( localizeWithPath(_moduleId, 14, "Select Profile Template File")),
+                });
+                if (!profileLocation) {
+                    return null;
+                }
+                return profileLocation[0];
+            }
+        }));
+        disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarShare, {
+            command: {
+                id,
+                title: ( localize2WithPath(_moduleId, 15, "Import Profile...")),
+                precondition: PROFILES_ENABLEMENT_CONTEXT,
+            },
+        }));
+        return disposables;
+    }
+    registerCreateFromCurrentProfileAction() {
+        const that = this;
+        this._register(registerAction2(class CreateFromCurrentProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.profiles.actions.createFromCurrentProfile',
+                    title: ( localize2WithPath(_moduleId, 16, "Save Current Profile As...")),
+                    category: PROFILES_CATEGORY,
+                    f1: true,
+                    precondition: PROFILES_ENABLEMENT_CONTEXT
+                });
+            }
+            run(accessor) {
+                return that.userDataProfileImportExportService.createProfile(that.userDataProfileService.currentProfile);
+            }
+        }));
+    }
+    registerCreateProfileAction() {
+        const that = this;
+        this._register(registerAction2(class CreateProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.profiles.actions.createProfile',
+                    title: ( localize2WithPath(_moduleId, 17, "Create Profile...")),
+                    category: PROFILES_CATEGORY,
+                    precondition: PROFILES_ENABLEMENT_CONTEXT,
+                    f1: true,
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '3_manage_profiles',
+                            when: PROFILES_ENABLEMENT_CONTEXT,
+                            order: 1
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                return that.userDataProfileImportExportService.createProfile();
+            }
+        }));
+    }
+    registerDeleteProfileAction() {
+        this._register(registerAction2(class DeleteProfileAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.profiles.actions.deleteProfile',
+                    title: ( localize2WithPath(_moduleId, 18, "Delete Profile...")),
+                    category: PROFILES_CATEGORY,
+                    f1: true,
+                    precondition: ( (ContextKeyExpr.and(PROFILES_ENABLEMENT_CONTEXT, HAS_PROFILES_CONTEXT))),
+                    menu: [
+                        {
+                            id: ProfilesMenu,
+                            group: '3_manage_profiles',
+                            when: PROFILES_ENABLEMENT_CONTEXT,
+                            order: 2
+                        }
+                    ]
+                });
+            }
+            async run(accessor) {
+                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);
+                const profiles = userDataProfilesService.profiles.filter(p => !p.isDefault && !p.isTransient);
+                if (profiles.length) {
+                    const picks = await quickInputService.pick(( (profiles.map(profile => ({
+                        label: profile.name,
+                        description: profile.id === userDataProfileService.currentProfile.id ? ( localizeWithPath(_moduleId, 19, "Current")) : undefined,
+                        profile
+                    })))), {
+                        title: ( localizeWithPath(_moduleId, 20, "Delete Profile...")),
+                        placeHolder: ( localizeWithPath(_moduleId, 21, "Select Profiles to Delete")),
+                        canPickMany: true
+                    });
+                    if (picks) {
+                        try {
+                            await Promise.all(( (picks.map(pick => userDataProfileManagementService.removeProfile(pick.profile)))));
+                        }
+                        catch (error) {
+                            notificationService.error(error);
+                        }
+                    }
+                }
+            }
+        }));
+    }
+    registerHelpAction() {
+        this._register(registerAction2(class HelpAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.profiles.actions.help',
+                    title: PROFILES_TITLE,
+                    category: Categories.Help,
+                    menu: [{
+                            id: MenuId.CommandPalette,
+                        }],
+                });
+            }
+            run(accessor) {
+                return accessor.get(IOpenerService).open(( (URI.parse('https://aka.ms/vscode-profiles-help'))));
+            }
+        }));
+    }
+    async getProfileTemplatesQuickPickItems() {
+        const quickPickItems = [];
+        const profileTemplates = await this.userDataProfileManagementService.getBuiltinProfileTemplates();
+        for (const template of profileTemplates) {
+            quickPickItems.push({
+                label: template.name,
+                ...template
+            });
+        }
+        return quickPickItems;
+    }
+    async reportWorkspaceProfileInfo() {
+        await this.lifecycleService.when(4 );
+        const workspaceId = await this.workspaceTagsService.getTelemetryWorkspaceId(this.workspaceContextService.getWorkspace(), this.workspaceContextService.getWorkbenchState());
+        this.telemetryService.publicLog2('workspaceProfileInfo', {
+            workspaceId,
+            defaultProfile: this.userDataProfileService.currentProfile.isDefault
+        });
+    }
+};
+UserDataProfilesWorkbenchContribution = ( (__decorate([
+    ( (__param(0, IUserDataProfileService))),
+    ( (__param(1, IUserDataProfilesService))),
+    ( (__param(2, IUserDataProfileManagementService))),
+    ( (__param(3, IUserDataProfileImportExportService))),
+    ( (__param(4, ITelemetryService))),
+    ( (__param(5, IWorkspaceContextService))),
+    ( (__param(6, IWorkspaceTagsService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, ILifecycleService)))
+], UserDataProfilesWorkbenchContribution)));
+
+export { UserDataProfilesWorkbenchContribution };

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

@@ -0,0 +1,159 @@
+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 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { PROFILES_CATEGORY, PROFILES_ENABLEMENT_CONTEXT, HAS_PROFILES_CONTEXT, MANAGE_PROFILES_ACTION_ID, ProfilesMenu } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IUserDataProfileManagementService, IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+
+const _moduleId = "vs/workbench/contrib/userDataProfile/browser/userDataProfileActions";
+class CreateTransientProfileAction extends Action2 {
+    static { this.ID = 'workbench.profiles.actions.createTemporaryProfile'; }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 0, "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(_moduleId, 1, "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(_moduleId, 2, 'Rename {0}', profile.name)),
+            validateInput: async (value) => {
+                if (profile.name !== value && ( (userDataProfilesService.profiles.some(p => p.name === value)))) {
+                    return ( localizeWithPath(_moduleId, 3, "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(_moduleId, 4, "Current")) : undefined,
+            profile
+        })))), {
+            title: ( localizeWithPath(_moduleId, 5, "Rename Profile...")),
+            placeHolder: ( localizeWithPath(_moduleId, 6, "Select Profile to Rename")),
+        });
+        return pick?.profile;
+    }
+}
+registerAction2(RenameProfileAction);
+registerAction2(class ManageProfilesAction extends Action2 {
+    constructor() {
+        super({
+            id: MANAGE_PROFILES_ACTION_ID,
+            title: ( localize2WithPath(_moduleId, 7, "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(_moduleId, 8, "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(_moduleId, 9, "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 'vscode/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.service';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+
+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 };