@codingame/monaco-vscode-user-data-profile-service-override 8.0.4 → 9.0.2

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

@@ -3,23 +3,19 @@ import { Disposable, MutableDisposable, DisposableStore } from 'vscode/vscode/vs
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { MenuId, MenuRegistry, 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 { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 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 { CURRENT_PROFILE_CONTEXT, PROFILES_ENABLEMENT_CONTEXT, IS_CURRENT_PROFILE_TRANSIENT_CONTEXT, HAS_PROFILES_CONTEXT, isProfileURL, PROFILES_CATEGORY, PROFILES_TITLE } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { 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 { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 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';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
@@ -30,33 +26,25 @@ import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/d
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { Extensions, ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { workbenchConfigurationNodeBase } from 'vscode/vscode/vs/workbench/common/configuration';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url.service';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
 
 const OpenProfileMenu = ( (new MenuId('OpenProfile')));
-const CONFIG_ENABLE_NEW_PROFILES_UI = 'workbench.experimental.enableNewProfilesUI';
-const CONTEXT_ENABLE_NEW_PROFILES_UI = ( (ContextKeyExpr.equals('config.workbench.experimental.enableNewProfilesUI', true)));
 let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContribution extends Disposable {
     static { this.ID = 'workbench.contrib.userDataProfiles'; }
-    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, userDataProfileImportExportService, telemetryService, workspaceContextService, workspaceTagsService, contextKeyService, configurationService, editorGroupsService, instantiationService, productService, lifecycleService) {
+    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, telemetryService, workspaceContextService, workspaceTagsService, contextKeyService, editorGroupsService, instantiationService, lifecycleService, urlService, environmentService) {
         super();
         this.userDataProfileService = userDataProfileService;
         this.userDataProfilesService = userDataProfilesService;
         this.userDataProfileManagementService = userDataProfileManagementService;
-        this.userDataProfileImportExportService = userDataProfileImportExportService;
         this.telemetryService = telemetryService;
         this.workspaceContextService = workspaceContextService;
         this.workspaceTagsService = workspaceTagsService;
-        this.configurationService = configurationService;
         this.editorGroupsService = editorGroupsService;
         this.instantiationService = instantiationService;
-        this.productService = productService;
         this.lifecycleService = lifecycleService;
-        this.startTime = Date.now();
+        this.urlService = urlService;
         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);
@@ -69,86 +57,53 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
         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.registerConfiguration();
         this.registerEditor();
         this.registerActions();
+        this._register(this.urlService.registerHandler(this));
         if (isWeb) {
             lifecycleService.when(LifecyclePhase.Eventually).then(() => userDataProfilesService.cleanUp());
         }
         this.reportWorkspaceProfileInfo();
+        if (environmentService.options?.profileToPreview) {
+            lifecycleService.when(LifecyclePhase.Restored).then(() => this.handleURL(URI.revive(environmentService.options.profileToPreview)));
+        }
+    }
+    async handleURL(uri) {
+        if (isProfileURL(uri)) {
+            const editor = await this.openProfilesEditor();
+            if (editor) {
+                editor.createNewProfile(uri);
+                return true;
+            }
+        }
+        return false;
     }
     async openProfilesEditor() {
         const editor = await this.editorGroupsService.activeGroup.openEditor(( (new UserDataProfilesEditorInput(this.instantiationService))));
         return editor;
     }
-    isNewProfilesUIEnabled() {
-        return this.configurationService.getValue(CONFIG_ENABLE_NEW_PROFILES_UI) === true;
-    }
-    registerConfiguration() {
-        ( (Registry.as(Extensions.Configuration)))
-            .registerConfiguration({
-            ...workbenchConfigurationNodeBase,
-            properties: {
-                [CONFIG_ENABLE_NEW_PROFILES_UI]: {
-                    type: 'boolean',
-                    description: ( localize(8813, "Enables the new profiles UI.")),
-                    default: this.productService.quality !== 'stable',
-                    scope: ConfigurationScope.APPLICATION,
-                }
-            }
-        });
-    }
     registerEditor() {
-        ( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(UserDataProfilesEditor, UserDataProfilesEditor.ID, ( localize(8814, "Profiles Editor"))), [
+        ( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(UserDataProfilesEditor, UserDataProfilesEditor.ID, ( localize(8855, "Profiles Editor"))), [
             ( (new SyncDescriptor(UserDataProfilesEditorInput)))
         ]);
         ( (Registry.as(EditorExtensions.EditorFactory))).registerEditorSerializer(UserDataProfilesEditorInput.ID, UserDataProfilesEditorInputSerializer);
     }
     registerActions() {
-        this.registerProfileSubMenu();
         this._register(this.registerManageProfilesAction());
         this._register(this.registerSwitchProfileAction());
         this.registerOpenProfileSubMenu();
         this.registerNewWindowWithProfileAction();
         this.registerProfilesActions();
         this._register(this.userDataProfilesService.onDidChangeProfiles(() => this.registerProfilesActions()));
-        this.registerCurrentProfilesActions();
-        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => this.registerCurrentProfilesActions()));
+        this._register(this.registerExportCurrentProfileAction());
         this.registerCreateFromCurrentProfileAction();
         this.registerNewProfileAction();
         this.registerDeleteProfileAction();
         this.registerHelpAction();
     }
-    registerProfileSubMenu() {
-        const getProfilesTitle = () => {
-            return ( localize(8815, "Profile ({0})", this.userDataProfileService.currentProfile.name));
-        };
-        const when = ( (ContextKeyExpr.or(
-             (CONTEXT_ENABLE_NEW_PROFILES_UI.negate()),
-            HAS_PROFILES_CONTEXT
-        )));
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            get title() {
-                return getProfilesTitle();
-            },
-            submenu: ProfilesMenu,
-            group: '2_configuration',
-            order: 1,
-            when,
-        });
-        MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
-            get title() {
-                return getProfilesTitle();
-            },
-            submenu: ProfilesMenu,
-            group: '2_configuration',
-            order: 1,
-            when,
-        });
-    }
     registerOpenProfileSubMenu() {
         MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
-            title: ( localize(8816, "New Window with Profile")),
+            title: ( localize(8856, "New Window with Profile")),
             submenu: OpenProfileMenu,
             group: '1_new',
             order: 4,
@@ -158,46 +113,16 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
         this.profilesDisposable.value = ( (new DisposableStore()));
         for (const profile of this.userDataProfilesService.profiles) {
             if (!profile.isTransient) {
-                this.profilesDisposable.value.add(this.registerProfileEntryAction(profile));
                 this.profilesDisposable.value.add(this.registerNewWindowAction(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) {
-                    if (profile.isDefault && Date.now() - that.startTime < ((1000 * 20) )) {
-                        that.telemetryService.publicLog2('profiles:newwindowprofile', {
-                            emptyWindow: that.workspaceContextService.getWorkbenchState() === WorkbenchState.EMPTY
-                        });
-                    }
-                    return that.userDataProfileManagementService.switchProfile(profile);
-                }
-            }
-        });
-    }
     registerNewWindowWithProfileAction() {
         return registerAction2(class NewWindowWithProfileAction extends Action2 {
             constructor() {
                 super({
                     id: `workbench.profiles.actions.newWindowWithProfile`,
-                    title: ( localize2(8817, "New Window with Profile...")),
+                    title: ( localize2(8857, "New Window with Profile...")),
                     category: PROFILES_CATEGORY,
                     precondition: HAS_PROFILES_CONTEXT,
                     f1: true,
@@ -211,8 +136,8 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
                     label: profile.name,
                     profile
                 })))), {
-                    title: ( localize(8818, "New Window with Profile")),
-                    placeHolder: ( localize(8819, "Select Profile")),
+                    title: ( localize(8858, "New Window with Profile")),
+                    placeHolder: ( localize(8859, "Select Profile")),
                     canPickMany: false
                 });
                 if (pick) {
@@ -223,12 +148,12 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
     }
     registerNewWindowAction(profile) {
         const disposables = ( (new DisposableStore()));
-        const id = `workbench.action.openProfile.${profile.name.toLowerCase().replace('/\s+/', '_')}`;
+        const id = `workbench.action.openProfile.${profile.name.replace('/\s+/', '_')}`;
         disposables.add(registerAction2(class NewWindowAction extends Action2 {
             constructor() {
                 super({
                     id,
-                    title: ( localize2(8820, "{0}", profile.name)),
+                    title: ( localize2(8860, "{0}", profile.name)),
                     menu: {
                         id: OpenProfileMenu,
                         group: '0_profiles',
@@ -245,18 +170,19 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             command: {
                 id,
                 category: PROFILES_CATEGORY,
-                title: ( localize2(8821, "Open {0} Profile", profile.name)),
+                title: ( localize2(8861, "Open {0} Profile", profile.name)),
                 precondition: HAS_PROFILES_CONTEXT
             },
         }));
         return disposables;
     }
     registerSwitchProfileAction() {
+        const that = this;
         return registerAction2(class SwitchProfileAction extends Action2 {
             constructor() {
                 super({
                     id: `workbench.profiles.actions.switchProfile`,
-                    title: ( localize2(8822, 'Switch Profile...')),
+                    title: ( localize2(8862, 'Switch Profile...')),
                     category: PROFILES_CATEGORY,
                     f1: true,
                     precondition: PROFILES_ENABLEMENT_CONTEXT,
@@ -264,26 +190,23 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             }
             async run(accessor) {
                 const quickInputService = accessor.get(IQuickInputService);
-                const menuService = accessor.get(IMenuService);
-                const menu = menuService.getMenuActions(ProfilesMenu, accessor.get(IContextKeyService));
-                const actions = menu.find(([group]) => group === '0_profiles')?.[1] ?? [];
-                const result = await quickInputService.pick(( (actions.map(action => ({
-                    action,
-                    label: action.checked ? `$(check) ${action.label}` : action.label,
-                })))), {
-                    placeHolder: ( localize(8823, "Select Profile"))
+                const items = [];
+                for (const profile of that.userDataProfilesService.profiles) {
+                    items.push({
+                        id: profile.id,
+                        label: profile.id === that.userDataProfileService.currentProfile.id ? `$(check) ${profile.name}` : profile.name,
+                        profile,
+                    });
+                }
+                const result = await quickInputService.pick(items.sort((a, b) => a.profile.name.localeCompare(b.profile.name)), {
+                    placeHolder: ( localize(8863, "Select Profile"))
                 });
-                await result?.action.run();
+                if (result) {
+                    await that.userDataProfileManagementService.switchProfile(result.profile);
+                }
             }
         });
     }
-    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());
-    }
     registerManageProfilesAction() {
         const disposables = ( (new DisposableStore()));
         disposables.add(registerAction2(class ManageProfilesAction extends Action2 {
@@ -291,32 +214,19 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
                 super({
                     id: `workbench.profiles.actions.manageProfiles`,
                     title: {
-                        ...( localize2(8824, "Profiles")),
-                        mnemonicTitle: ( localize(8825, "&&Profiles")),
+                        ...( localize2(8864, "Profiles")),
+                        mnemonicTitle: ( localize(8865, "&&Profiles")),
                     },
                     menu: [
                         {
                             id: MenuId.GlobalActivity,
                             group: '2_configuration',
                             order: 1,
-                            when: ( (ContextKeyExpr.and(
-                                CONTEXT_ENABLE_NEW_PROFILES_UI,
-                                 (HAS_PROFILES_CONTEXT.negate())
-                            ))),
                         },
                         {
                             id: MenuId.MenubarPreferencesMenu,
                             group: '2_configuration',
                             order: 1,
-                            when: ( (ContextKeyExpr.and(
-                                CONTEXT_ENABLE_NEW_PROFILES_UI,
-                                 (HAS_PROFILES_CONTEXT.negate())
-                            ))),
-                        },
-                        {
-                            id: ProfilesMenu,
-                            group: '1_manage',
-                            when: ( (ContextKeyExpr.and(CONTEXT_ENABLE_NEW_PROFILES_UI, HAS_PROFILES_CONTEXT))),
                         },
                     ]
                 });
@@ -331,69 +241,11 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             command: {
                 id: 'workbench.profiles.actions.manageProfiles',
                 category: Categories.Preferences,
-                title: ( localize2(8826, "Open Profiles (UI)")),
-                precondition: CONTEXT_ENABLE_NEW_PROFILES_UI,
+                title: ( localize2(8866, "Open Profiles (UI)")),
             },
         }));
         return disposables;
     }
-    registerEditCurrentProfileAction() {
-        const that = this;
-        return registerAction2(class RenameCurrentProfileAction extends Action2 {
-            constructor() {
-                const precondition = ( (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: ( localize2(8827, "Edit Profile...")),
-                    precondition,
-                    f1: true,
-                    menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '2_manage_current',
-                            when: ( (ContextKeyExpr.and(precondition,  (CONTEXT_ENABLE_NEW_PROFILES_UI.negate())))),
-                            order: 2
-                        }
-                    ]
-                });
-            }
-            run(accessor) {
-                if (that.isNewProfilesUIEnabled()) {
-                    return that.openProfilesEditor();
-                }
-                else {
-                    return that.userDataProfileImportExportService.editProfile(that.userDataProfileService.currentProfile);
-                }
-            }
-        });
-    }
-    registerShowCurrentProfileContentsAction() {
-        const id = 'workbench.profiles.actions.showProfileContents';
-        return registerAction2(class ShowProfileContentsAction extends Action2 {
-            constructor() {
-                super({
-                    id,
-                    title: ( localize2(8828, "Show Profile Contents")),
-                    category: PROFILES_CATEGORY,
-                    menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '2_manage_current',
-                            order: 3,
-                            when: ( (CONTEXT_ENABLE_NEW_PROFILES_UI.negate()))
-                        }
-                    ]
-                });
-            }
-            async run(accessor) {
-                const userDataProfileImportExportService = accessor.get(IUserDataProfileImportExportService);
-                return userDataProfileImportExportService.showProfileContents();
-            }
-        });
-    }
     registerExportCurrentProfileAction() {
         const that = this;
         const disposables = ( (new DisposableStore()));
@@ -402,35 +254,21 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             constructor() {
                 super({
                     id,
-                    title: ( localize2(8829, "Export Profile...")),
+                    title: ( localize2(8867, "Export Profile...")),
                     category: PROFILES_CATEGORY,
-                    precondition: ( (IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT.toNegated())),
-                    menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '4_import_export_profiles',
-                            order: 1,
-                            when: ( (CONTEXT_ENABLE_NEW_PROFILES_UI.negate())),
-                        }, {
-                            id: MenuId.CommandPalette
-                        }
-                    ]
+                    f1: true,
                 });
             }
-            async run(accessor) {
-                if (that.isNewProfilesUIEnabled()) {
-                    return that.openProfilesEditor();
-                }
-                else {
-                    return that.userDataProfileImportExportService.exportProfile2();
-                }
+            async run() {
+                const editor = await that.openProfilesEditor();
+                editor?.selectProfile(that.userDataProfileService.currentProfile);
             }
         }));
         disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarShare, {
             command: {
                 id,
                 title: ( localize2(
-                    8830,
+                    8868,
                     "Export Profile ({0})...",
                     that.userDataProfileService.currentProfile.name
                 )),
@@ -439,121 +277,21 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
         }));
         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: ( localize2(8831, "Import Profile...")),
-                    category: PROFILES_CATEGORY,
-                    precondition: ( (IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT.toNegated())),
-                    menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '4_import_export_profiles',
-                            when: ( (ContextKeyExpr.and(
-                                PROFILES_ENABLEMENT_CONTEXT,
-                                 (CONTEXT_ENABLE_NEW_PROFILES_UI.negate())
-                            ))),
-                            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: ( localize(8832, "Import from URL")) });
-                    }
-                    quickPickItems.push({ label: ( localize(8833, "Select File...")) });
-                    if (profileTemplateQuickPickItems.length) {
-                        quickPickItems.push({
-                            type: 'separator',
-                            label: ( localize(8834, "Profile Templates"))
-                        }, ...profileTemplateQuickPickItems);
-                    }
-                    quickPick.items = quickPickItems;
-                };
-                quickPick.title = ( localize(8835, "Import from Profile Template..."));
-                quickPick.placeholder = ( localize(8836, "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(( localize(8837, "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: ( localize(8838, "Select Profile Template File")),
-                });
-                if (!profileLocation) {
-                    return null;
-                }
-                return profileLocation[0];
-            }
-        }));
-        disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarShare, {
-            command: {
-                id,
-                title: ( localize2(8839, "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: ( localize2(8840, "Save Current Profile As...")),
+                    title: ( localize2(8869, "Save Current Profile As...")),
                     category: PROFILES_CATEGORY,
                     f1: true,
                     precondition: PROFILES_ENABLEMENT_CONTEXT
                 });
             }
-            run(accessor) {
-                return that.userDataProfileImportExportService.createProfile(that.userDataProfileService.currentProfile);
+            async run() {
+                const editor = await that.openProfilesEditor();
+                editor?.createNewProfile(that.userDataProfileService.currentProfile);
             }
         }));
     }
@@ -563,20 +301,11 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             constructor() {
                 super({
                     id: 'workbench.profiles.actions.createProfile',
-                    title: ( localize2(8841, "New Profile...")),
+                    title: ( localize2(8870, "New Profile...")),
                     category: PROFILES_CATEGORY,
                     precondition: PROFILES_ENABLEMENT_CONTEXT,
                     f1: true,
                     menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '3_manage_profiles',
-                            when: ( (ContextKeyExpr.and(
-                                PROFILES_ENABLEMENT_CONTEXT,
-                                 (CONTEXT_ENABLE_NEW_PROFILES_UI.negate())
-                            ))),
-                            order: 1
-                        },
                         {
                             id: OpenProfileMenu,
                             group: '1_manage_profiles',
@@ -586,13 +315,8 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
                 });
             }
             async run(accessor) {
-                if (that.isNewProfilesUIEnabled()) {
-                    const editor = await that.openProfilesEditor();
-                    return editor?.createNewProfile();
-                }
-                else {
-                    return that.userDataProfileImportExportService.createProfile();
-                }
+                const editor = await that.openProfilesEditor();
+                return editor?.createNewProfile();
             }
         }));
     }
@@ -601,21 +325,10 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             constructor() {
                 super({
                     id: 'workbench.profiles.actions.deleteProfile',
-                    title: ( localize2(8842, "Delete Profile...")),
+                    title: ( localize2(8871, "Delete Profile...")),
                     category: PROFILES_CATEGORY,
                     f1: true,
                     precondition: ( (ContextKeyExpr.and(PROFILES_ENABLEMENT_CONTEXT, HAS_PROFILES_CONTEXT))),
-                    menu: [
-                        {
-                            id: ProfilesMenu,
-                            group: '3_manage_profiles',
-                            when: ( (ContextKeyExpr.and(
-                                PROFILES_ENABLEMENT_CONTEXT,
-                                 (CONTEXT_ENABLE_NEW_PROFILES_UI.negate())
-                            ))),
-                            order: 2
-                        }
-                    ]
                 });
             }
             async run(accessor) {
@@ -628,11 +341,11 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
                 if (profiles.length) {
                     const picks = await quickInputService.pick(( (profiles.map(profile => ({
                         label: profile.name,
-                        description: profile.id === userDataProfileService.currentProfile.id ? ( localize(8843, "Current")) : undefined,
+                        description: profile.id === userDataProfileService.currentProfile.id ? ( localize(8872, "Current")) : undefined,
                         profile
                     })))), {
-                        title: ( localize(8844, "Delete Profile...")),
-                        placeHolder: ( localize(8845, "Select Profiles to Delete")),
+                        title: ( localize(8873, "Delete Profile...")),
+                        placeHolder: ( localize(8874, "Select Profiles to Delete")),
                         canPickMany: true
                     });
                     if (picks) {
@@ -664,17 +377,6 @@ let UserDataProfilesWorkbenchContribution = class UserDataProfilesWorkbenchContr
             }
         }));
     }
-    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(LifecyclePhase.Eventually);
         const workspaceId = await this.workspaceTagsService.getTelemetryWorkspaceId(this.workspaceContextService.getWorkspace(), this.workspaceContextService.getWorkbenchState());
@@ -688,16 +390,15 @@ 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, IConfigurationService))),
-    ( (__param(9, IEditorGroupsService))),
-    ( (__param(10, IInstantiationService))),
-    ( (__param(11, IProductService))),
-    ( (__param(12, ILifecycleService)))
+    ( (__param(3, ITelemetryService))),
+    ( (__param(4, IWorkspaceContextService))),
+    ( (__param(5, IWorkspaceTagsService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, IEditorGroupsService))),
+    ( (__param(8, IInstantiationService))),
+    ( (__param(9, ILifecycleService))),
+    ( (__param(10, IURLService))),
+    ( (__param(11, IBrowserWorkbenchEnvironmentService)))
 ], UserDataProfilesWorkbenchContribution)));
 
 export { OpenProfileMenu, UserDataProfilesWorkbenchContribution };