@codingame/monaco-vscode-user-data-profile-service-override 6.0.3 → 7.0.1

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

@@ -5,9 +5,9 @@ import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-import { ProfileResourceType, toUserDataProfile, isUserDataProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+import { ProfileResourceType, isUserDataProfile, toUserDataProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
-import { IUserDataProfileService, IUserDataProfileManagementService, IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { IUserDataProfileManagementService, IUserDataProfileService, IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { Disposable, toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { equals } from 'vscode/vscode/vs/base/common/objects';
@@ -22,19 +22,36 @@ import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs
 import { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { RunOnceScheduler, createCancelablePromise } from 'vscode/vscode/vs/base/common/async';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { CancellationTokenSource, CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { CONFIG_NEW_WINDOW_PROFILE } from 'vscode/vscode/vs/workbench/common/configuration';
 
 var UserDataProfilesEditorModel_1;
 const _moduleId = "vs/workbench/contrib/userDataProfile/browser/userDataProfilesEditorModel";
+function isProfileResourceTypeElement(element) {
+    return element.resourceType !== undefined;
+}
+function isProfileResourceChildElement(element) {
+    return element.label !== undefined;
+}
 let AbstractUserDataProfileElement = class AbstractUserDataProfileElement extends Disposable {
-    constructor(name, icon, flags, isActive, userDataProfilesService, instantiationService) {
+    constructor(name, icon, flags, isActive, userDataProfileManagementService, userDataProfilesService, commandService, instantiationService) {
         super();
+        this.userDataProfileManagementService = userDataProfileManagementService;
         this.userDataProfilesService = userDataProfilesService;
+        this.commandService = commandService;
         this.instantiationService = instantiationService;
         this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
+        this.saveScheduler = this._register(( (new RunOnceScheduler(() => this.doSave(), 500))));
         this._name = '';
         this._active = false;
+        this._disabled = false;
         this._name = name;
         this._icon = icon;
         this._flags = flags;
@@ -43,15 +60,14 @@ let AbstractUserDataProfileElement = class AbstractUserDataProfileElement extend
             if (!e.message) {
                 this.validate();
             }
-            if (this.primaryAction) {
-                this.primaryAction.enabled = !this.message;
-            }
+            this.save();
         }));
     }
     get name() { return this._name; }
-    set name(label) {
-        if (this._name !== label) {
-            this._name = label;
+    set name(name) {
+        name = name.trim();
+        if (this._name !== name) {
+            this._name = name;
             this._onDidChange.fire({ name: true });
         }
     }
@@ -83,6 +99,13 @@ let AbstractUserDataProfileElement = class AbstractUserDataProfileElement extend
             this._onDidChange.fire({ message: true });
         }
     }
+    get disabled() { return this._disabled; }
+    set disabled(saving) {
+        if (this._disabled !== saving) {
+            this._disabled = saving;
+            this._onDidChange.fire({ disabled: true });
+        }
+    }
     getFlag(key) {
         return this.flags?.[key] ?? false;
     }
@@ -112,43 +135,133 @@ let AbstractUserDataProfileElement = class AbstractUserDataProfileElement extend
         this.message = undefined;
     }
     async getChildren(resourceType) {
+        if (resourceType === undefined) {
+            const resourceTypes = [
+                ProfileResourceType.Settings,
+                ProfileResourceType.Keybindings,
+                ProfileResourceType.Tasks,
+                ProfileResourceType.Snippets,
+                ProfileResourceType.Extensions
+            ];
+            return Promise.all(( (resourceTypes.map(async (r) => {
+                const children = (r === ProfileResourceType.Settings
+                    || r === ProfileResourceType.Keybindings
+                    || r === ProfileResourceType.Tasks) ? await this.getChildrenForResourceType(r) : [];
+                return {
+                    handle: r,
+                    checkbox: undefined,
+                    resourceType: r,
+                    action: children.length
+                        ? ( (new Action('_open', ( localizeWithPath(_moduleId, 3, "Open to the Side")), ThemeIcon.asClassName(Codicon.goToFile), true, () => children[0]?.action?.run())))
+                        : undefined
+                };
+            }))));
+        }
+        return this.getChildrenForResourceType(resourceType);
+    }
+    async getChildrenForResourceType(resourceType) {
         return [];
     }
     async getChildrenFromProfile(profile, resourceType) {
         profile = this.getFlag(resourceType) ? this.userDataProfilesService.defaultProfile : profile;
+        let children = [];
         switch (resourceType) {
             case ProfileResourceType.Settings:
-                return this.instantiationService.createInstance(SettingsResourceTreeItem, profile).getChildren();
+                children = await this.instantiationService.createInstance(SettingsResourceTreeItem, profile).getChildren();
+                break;
             case ProfileResourceType.Keybindings:
-                return this.instantiationService.createInstance(KeybindingsResourceTreeItem, profile).getChildren();
+                children = await this.instantiationService.createInstance(KeybindingsResourceTreeItem, profile).getChildren();
+                break;
             case ProfileResourceType.Snippets:
-                return (await this.instantiationService.createInstance(SnippetsResourceTreeItem, profile).getChildren()) ?? [];
+                children = (await this.instantiationService.createInstance(SnippetsResourceTreeItem, profile).getChildren()) ?? [];
+                break;
             case ProfileResourceType.Tasks:
-                return this.instantiationService.createInstance(TasksResourceTreeItem, profile).getChildren();
+                children = await this.instantiationService.createInstance(TasksResourceTreeItem, profile).getChildren();
+                break;
             case ProfileResourceType.Extensions:
-                return this.instantiationService.createInstance(ExtensionsResourceExportTreeItem, profile).getChildren();
-        }
-        return [];
+                children = await this.instantiationService.createInstance(ExtensionsResourceExportTreeItem, profile).getChildren();
+                break;
+        }
+        return (
+             (children.map(child => this.toUserDataProfileResourceChildElement(child)))
+        );
+    }
+    toUserDataProfileResourceChildElement(child) {
+        return {
+            handle: child.handle,
+            checkbox: child.checkbox,
+            label: child.label?.label ?? '',
+            resource: URI.revive(child.resourceUri),
+            icon: child.themeIcon,
+            action: ( (new Action('_openChild', ( localizeWithPath(_moduleId, 3, "Open to the Side")), ThemeIcon.asClassName(Codicon.goToFile), true, async () => {
+                if (child.parent.type === ProfileResourceType.Extensions) {
+                    await this.commandService.executeCommand('extension.open', child.handle, undefined, true, undefined, true);
+                }
+                else if (child.resourceUri) {
+                    await this.commandService.executeCommand(API_OPEN_EDITOR_COMMAND_ID, child.resourceUri, [SIDE_GROUP], undefined);
+                }
+            })))
+        };
     }
     getInitialName() {
         return '';
     }
+    save() {
+        this.saveScheduler.schedule();
+    }
+    hasUnsavedChanges(profile) {
+        if (this.name !== profile.name) {
+            return true;
+        }
+        if (this.icon !== profile.icon) {
+            return true;
+        }
+        if (!equals(this.flags ?? {}, profile.useDefaultFlags ?? {})) {
+            return true;
+        }
+        return false;
+    }
+    async saveProfile(profile) {
+        if (!this.hasUnsavedChanges(profile)) {
+            return;
+        }
+        this.validate();
+        if (this.message) {
+            return;
+        }
+        const useDefaultFlags = this.flags
+            ? this.flags.settings && this.flags.keybindings && this.flags.tasks && this.flags.globalState && this.flags.extensions ? undefined : this.flags
+            : undefined;
+        return await this.userDataProfileManagementService.updateProfile(profile, {
+            name: this.name,
+            icon: this.icon,
+            useDefaultFlags: profile.useDefaultFlags && !useDefaultFlags ? {} : useDefaultFlags
+        });
+    }
 };
 AbstractUserDataProfileElement = ( (__decorate([
-    ( (__param(4, IUserDataProfilesService))),
-    ( (__param(5, IInstantiationService)))
+    ( (__param(4, IUserDataProfileManagementService))),
+    ( (__param(5, IUserDataProfilesService))),
+    ( (__param(6, ICommandService))),
+    ( (__param(7, IInstantiationService)))
 ], AbstractUserDataProfileElement)));
 let UserDataProfileElement = class UserDataProfileElement extends AbstractUserDataProfileElement {
     get profile() { return this._profile; }
-    constructor(_profile, titleActions, contextMenuActions, userDataProfileService, userDataProfileManagementService, userDataProfilesService, instantiationService) {
-        super(_profile.name, _profile.icon, _profile.useDefaultFlags, userDataProfileService.currentProfile.id === _profile.id, userDataProfilesService, instantiationService);
+    constructor(_profile, titleButtons, titleActions, actions, userDataProfileService, configurationService, userDataProfileManagementService, userDataProfilesService, commandService, instantiationService) {
+        super(_profile.name, _profile.icon, _profile.useDefaultFlags, userDataProfileService.currentProfile.id === _profile.id, userDataProfileManagementService, userDataProfilesService, commandService, instantiationService);
         this._profile = _profile;
+        this.titleButtons = titleButtons;
         this.titleActions = titleActions;
-        this.contextMenuActions = contextMenuActions;
+        this.actions = actions;
         this.userDataProfileService = userDataProfileService;
-        this.userDataProfileManagementService = userDataProfileManagementService;
-        this.primaryAction = undefined;
-        this.saveScheduler = this._register(( (new RunOnceScheduler(() => this.doSave(), 500))));
+        this.configurationService = configurationService;
+        this._isNewWindowProfile = false;
+        this._isNewWindowProfile = this.configurationService.getValue(CONFIG_NEW_WINDOW_PROFILE) === this.profile.name;
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(CONFIG_NEW_WINDOW_PROFILE)) {
+                this.isNewWindowProfile = this.configurationService.getValue(CONFIG_NEW_WINDOW_PROFILE) === this.profile.name;
+            }
+        }));
         this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => this.active = this.userDataProfileService.currentProfile.id === this.profile.id));
         this._register(this.userDataProfilesService.onDidChangeProfiles(() => {
             const profile = this.userDataProfilesService.profiles.find(p => p.id === this.profile.id);
@@ -159,43 +272,26 @@ let UserDataProfileElement = class UserDataProfileElement extends AbstractUserDa
                 this.flags = profile.useDefaultFlags;
             }
         }));
-        this._register(this.onDidChange(e => {
-            this.save();
-        }));
     }
-    hasUnsavedChanges() {
-        if (this.name !== this.profile.name) {
-            return true;
-        }
-        if (this.icon !== this.profile.icon) {
-            return true;
+    async toggleNewWindowProfile() {
+        if (this._isNewWindowProfile) {
+            await this.configurationService.updateValue(CONFIG_NEW_WINDOW_PROFILE, null);
         }
-        if (!equals(this.flags ?? {}, this.profile.useDefaultFlags ?? {})) {
-            return true;
+        else {
+            await this.configurationService.updateValue(CONFIG_NEW_WINDOW_PROFILE, this.profile.name);
         }
-        return false;
     }
-    save() {
-        this.saveScheduler.schedule();
+    get isNewWindowProfile() { return this._isNewWindowProfile; }
+    set isNewWindowProfile(isNewWindowProfile) {
+        if (this._isNewWindowProfile !== isNewWindowProfile) {
+            this._isNewWindowProfile = isNewWindowProfile;
+            this._onDidChange.fire({ newWindowProfile: true });
+        }
     }
     async doSave() {
-        if (!this.hasUnsavedChanges()) {
-            return;
-        }
-        this.validate();
-        if (this.message) {
-            return;
-        }
-        const useDefaultFlags = this.flags
-            ? this.flags.settings && this.flags.keybindings && this.flags.tasks && this.flags.globalState && this.flags.extensions ? undefined : this.flags
-            : undefined;
-        await this.userDataProfileManagementService.updateProfile(this.profile, {
-            name: this.name,
-            icon: this.icon,
-            useDefaultFlags: this.profile.useDefaultFlags && !useDefaultFlags ? {} : useDefaultFlags
-        });
+        await this.saveProfile(this.profile);
     }
-    async getChildren(resourceType) {
+    async getChildrenForResourceType(resourceType) {
         return this.getChildrenFromProfile(this.profile, resourceType);
     }
     getInitialName() {
@@ -203,22 +299,26 @@ let UserDataProfileElement = class UserDataProfileElement extends AbstractUserDa
     }
 };
 UserDataProfileElement = ( (__decorate([
-    ( (__param(3, IUserDataProfileService))),
-    ( (__param(4, IUserDataProfileManagementService))),
-    ( (__param(5, IUserDataProfilesService))),
-    ( (__param(6, IInstantiationService)))
+    ( (__param(4, IUserDataProfileService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IUserDataProfileManagementService))),
+    ( (__param(7, IUserDataProfilesService))),
+    ( (__param(8, ICommandService))),
+    ( (__param(9, IInstantiationService)))
 ], UserDataProfileElement)));
 const USER_DATA_PROFILE_TEMPLATE_PREVIEW_SCHEME = 'userdataprofiletemplatepreview';
 let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileElement {
-    constructor(name, copyFrom, primaryAction, titleActions, contextMenuActions, fileService, userDataProfileImportExportService, userDataProfilesService, instantiationService) {
-        super(name, undefined, undefined, false, userDataProfilesService, instantiationService);
-        this.primaryAction = primaryAction;
+    constructor(name, copyFrom, titleButtons, titleActions, actions, fileService, userDataProfileImportExportService, userDataProfileManagementService, userDataProfilesService, commandService, instantiationService) {
+        super(name, undefined, undefined, false, userDataProfileManagementService, userDataProfilesService, commandService, instantiationService);
+        this.titleButtons = titleButtons;
         this.titleActions = titleActions;
-        this.contextMenuActions = contextMenuActions;
+        this.actions = actions;
         this.fileService = fileService;
         this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this.template = null;
         this._copyFrom = copyFrom;
         this._copyFlags = this.getCopyFlagsFrom(copyFrom);
+        this.initialize();
         this._register(this.fileService.registerProvider(USER_DATA_PROFILE_TEMPLATE_PREVIEW_SCHEME, this._register(( (new InMemoryFileSystemProvider())))));
     }
     get copyFrom() { return this._copyFrom; }
@@ -228,6 +328,11 @@ let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileE
             this._onDidChange.fire({ copyFrom: true });
             this.flags = undefined;
             this.copyFlags = this.getCopyFlagsFrom(copyFrom);
+            if (copyFrom instanceof URI) {
+                this.templatePromise?.cancel();
+                this.templatePromise = undefined;
+            }
+            this.initialize();
         }
     }
     get copyFlags() { return this._copyFlags; }
@@ -237,6 +342,13 @@ let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileE
             this._onDidChange.fire({ copyFlags: true });
         }
     }
+    get previewProfile() { return this._previewProfile; }
+    set previewProfile(profile) {
+        if (this._previewProfile !== profile) {
+            this._previewProfile = profile;
+            this._onDidChange.fire({ preview: true });
+        }
+    }
     getCopyFlagsFrom(copyFrom) {
         return copyFrom ? {
             settings: true,
@@ -246,6 +358,73 @@ let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileE
             extensions: true
         } : undefined;
     }
+    async initialize() {
+        this.disabled = true;
+        try {
+            if (this.copyFrom instanceof URI) {
+                await this.resolveTemplate(this.copyFrom);
+                if (this.template) {
+                    this.name = this.template.name ?? '';
+                    this.icon = this.template.icon;
+                    this.setCopyFlag(ProfileResourceType.Settings, !!this.template.settings);
+                    this.setCopyFlag(ProfileResourceType.Keybindings, !!this.template.keybindings);
+                    this.setCopyFlag(ProfileResourceType.Tasks, !!this.template.tasks);
+                    this.setCopyFlag(ProfileResourceType.Snippets, !!this.template.snippets);
+                    this.setCopyFlag(ProfileResourceType.Extensions, !!this.template.extensions);
+                }
+                return;
+            }
+            if (isUserDataProfile(this.copyFrom)) {
+                this.name = `${this.copyFrom.name} (Copy)`;
+                this.icon = this.copyFrom.icon;
+                this.setCopyFlag(ProfileResourceType.Settings, true);
+                this.setCopyFlag(ProfileResourceType.Keybindings, true);
+                this.setCopyFlag(ProfileResourceType.Tasks, true);
+                this.setCopyFlag(ProfileResourceType.Snippets, true);
+                this.setCopyFlag(ProfileResourceType.Extensions, true);
+                return;
+            }
+            this.name = ( localizeWithPath(_moduleId, 4, "Untitled"));
+            this.icon = undefined;
+            this.setCopyFlag(ProfileResourceType.Settings, false);
+            this.setCopyFlag(ProfileResourceType.Keybindings, false);
+            this.setCopyFlag(ProfileResourceType.Tasks, false);
+            this.setCopyFlag(ProfileResourceType.Snippets, false);
+            this.setCopyFlag(ProfileResourceType.Extensions, false);
+        }
+        finally {
+            this.disabled = false;
+        }
+    }
+    async resolveTemplate(uri) {
+        if (!this.templatePromise) {
+            this.templatePromise = createCancelablePromise(async (token) => {
+                const template = await this.userDataProfileImportExportService.resolveProfileTemplate(uri);
+                if (!token.isCancellationRequested) {
+                    this.template = template;
+                }
+            });
+        }
+        await this.templatePromise;
+        return this.template;
+    }
+    hasResource(resourceType) {
+        if (this.template) {
+            switch (resourceType) {
+                case ProfileResourceType.Settings:
+                    return !!this.template.settings;
+                case ProfileResourceType.Keybindings:
+                    return !!this.template.keybindings;
+                case ProfileResourceType.Snippets:
+                    return !!this.template.snippets;
+                case ProfileResourceType.Tasks:
+                    return !!this.template.tasks;
+                case ProfileResourceType.Extensions:
+                    return !!this.template.extensions;
+            }
+        }
+        return true;
+    }
     getCopyFlag(key) {
         return this.copyFlags?.[key] ?? false;
     }
@@ -254,23 +433,32 @@ let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileE
         flags[key] = value;
         this.copyFlags = flags;
     }
-    async getChildren(resourceType) {
+    getCopyFromName() {
+        if (isUserDataProfile(this.copyFrom)) {
+            return this.copyFrom.name;
+        }
+        if (this.template) {
+            return this.template.name;
+        }
+        return undefined;
+    }
+    async getChildrenForResourceType(resourceType) {
+        if (this.getFlag(resourceType)) {
+            return this.getChildrenFromProfile(this.userDataProfilesService.defaultProfile, resourceType);
+        }
         if (!this.getCopyFlag(resourceType)) {
             return [];
         }
         if (this.copyFrom instanceof URI) {
-            const template = await this.userDataProfileImportExportService.resolveProfileTemplate(this.copyFrom);
-            if (!template) {
+            await this.resolveTemplate(this.copyFrom);
+            if (!this.template) {
                 return [];
             }
-            return this.getChildrenFromProfileTemplate(template, resourceType);
+            return this.getChildrenFromProfileTemplate(this.template, resourceType);
         }
         if (this.copyFrom) {
             return this.getChildrenFromProfile(this.copyFrom, resourceType);
         }
-        if (this.getFlag(resourceType)) {
-            return this.getChildrenFromProfile(this.userDataProfilesService.defaultProfile, resourceType);
-        }
         return [];
     }
     async getChildrenFromProfileTemplate(profileTemplate, resourceType) {
@@ -279,36 +467,57 @@ let NewProfileElement = class NewProfileElement extends AbstractUserDataProfileE
             case ProfileResourceType.Settings:
                 if (profileTemplate.settings) {
                     await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile);
+                    return this.getChildrenFromProfile(profile, resourceType);
                 }
-                return this.getChildrenFromProfile(profile, resourceType);
+                return [];
             case ProfileResourceType.Keybindings:
                 if (profileTemplate.keybindings) {
                     await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile);
+                    return this.getChildrenFromProfile(profile, resourceType);
                 }
-                return this.getChildrenFromProfile(profile, resourceType);
+                return [];
             case ProfileResourceType.Snippets:
                 if (profileTemplate.snippets) {
                     await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile);
+                    return this.getChildrenFromProfile(profile, resourceType);
                 }
-                return this.getChildrenFromProfile(profile, resourceType);
+                return [];
             case ProfileResourceType.Tasks:
                 if (profileTemplate.tasks) {
                     await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile);
+                    return this.getChildrenFromProfile(profile, resourceType);
                 }
-                return this.getChildrenFromProfile(profile, resourceType);
+                return [];
             case ProfileResourceType.Extensions:
                 if (profileTemplate.extensions) {
-                    return this.instantiationService.createInstance(ExtensionsResourceImportTreeItem, profileTemplate.extensions).getChildren();
+                    const children = await this.instantiationService.createInstance(ExtensionsResourceImportTreeItem, profileTemplate.extensions).getChildren();
+                    return (
+                         (children.map(child => this.toUserDataProfileResourceChildElement(child)))
+                    );
                 }
+                return [];
         }
         return [];
     }
+    getInitialName() {
+        return this.previewProfile?.name ?? '';
+    }
+    async doSave() {
+        if (this.previewProfile) {
+            const profile = await this.saveProfile(this.previewProfile);
+            if (profile) {
+                this.previewProfile = profile;
+            }
+        }
+    }
 };
 NewProfileElement = ( (__decorate([
     ( (__param(5, IFileService))),
     ( (__param(6, IUserDataProfileImportExportService))),
-    ( (__param(7, IUserDataProfilesService))),
-    ( (__param(8, IInstantiationService)))
+    ( (__param(7, IUserDataProfileManagementService))),
+    ( (__param(8, IUserDataProfilesService))),
+    ( (__param(9, ICommandService))),
+    ( (__param(10, IInstantiationService)))
 ], NewProfileElement)));
 let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends EditorModel {
     static { UserDataProfilesEditorModel_1 = this; }
@@ -337,7 +546,7 @@ let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends Edit
             return a.name.localeCompare(b.name);
         });
     }
-    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, userDataProfileImportExportService, dialogService, telemetryService, instantiationService) {
+    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, userDataProfileImportExportService, dialogService, telemetryService, hostService, instantiationService) {
         super();
         this.userDataProfileService = userDataProfileService;
         this.userDataProfilesService = userDataProfilesService;
@@ -345,45 +554,62 @@ let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends Edit
         this.userDataProfileImportExportService = userDataProfileImportExportService;
         this.dialogService = dialogService;
         this.telemetryService = telemetryService;
+        this.hostService = hostService;
         this.instantiationService = instantiationService;
         this._profiles = [];
         this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
         for (const profile of userDataProfilesService.profiles) {
-            this._profiles.push(this.createProfileElement(profile));
+            if (!profile.isTransient) {
+                this._profiles.push(this.createProfileElement(profile));
+            }
         }
         this._register(toDisposable(() => ( (this._profiles.splice(0, this._profiles.length).map(([, disposables]) => disposables.dispose())))));
         this._register(userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e)));
     }
     onDidChangeProfiles(e) {
+        let changed = false;
         for (const profile of e.added) {
-            if (profile.name !== this.newProfileElement?.name) {
+            if (!profile.isTransient && profile.name !== this.newProfileElement?.name) {
+                changed = true;
                 this._profiles.push(this.createProfileElement(profile));
             }
         }
         for (const profile of e.removed) {
-            this._profiles.findIndex(([p]) => p instanceof UserDataProfileElement && p.profile.id === profile.id);
+            if (profile.id === this.newProfileElement?.previewProfile?.id) {
+                this.newProfileElement.previewProfile = undefined;
+            }
+            const index = this._profiles.findIndex(([p]) => p instanceof UserDataProfileElement && p.profile.id === profile.id);
+            if (index !== -1) {
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._onDidChange.fire(undefined);
         }
-        this._onDidChange.fire(undefined);
     }
     createProfileElement(profile) {
         const disposables = ( (new DisposableStore()));
-        const activateAction = disposables.add(( (new Action('userDataProfile.activate', ( localizeWithPath(_moduleId, 3, "Activate")), ThemeIcon.asClassName(Codicon.check), true, () => this.userDataProfileManagementService.switchProfile(profile)))));
-        activateAction.checked = this.userDataProfileService.currentProfile.id === profile.id;
-        disposables.add(this.userDataProfileService.onDidChangeCurrentProfile(() => activateAction.checked = this.userDataProfileService.currentProfile.id === profile.id));
-        const copyFromProfileAction = disposables.add(( (new Action('userDataProfile.copyFromProfile', ( localizeWithPath(_moduleId, 4, "Save As...")), ThemeIcon.asClassName(Codicon.copy), true, () => this.createNewProfile(profile)))));
-        const exportAction = disposables.add(( (new Action('userDataProfile.export', ( localizeWithPath(_moduleId, 5, "Export...")), ThemeIcon.asClassName(Codicon.export), true, () => this.exportProfile(profile)))));
-        const deleteAction = disposables.add(( (new Action('userDataProfile.delete', ( localizeWithPath(_moduleId, 6, "Delete")), ThemeIcon.asClassName(Codicon.trash), true, () => this.removeProfile(profile)))));
+        const activateAction = disposables.add(( (new Action('userDataProfile.activate', ( localizeWithPath(_moduleId, 5, "Use for Current Window")), ThemeIcon.asClassName(Codicon.check), true, () => this.userDataProfileManagementService.switchProfile(profileElement.profile)))));
+        const copyFromProfileAction = disposables.add(( (new Action('userDataProfile.copyFromProfile', ( localizeWithPath(_moduleId, 6, "Duplicate...")), ThemeIcon.asClassName(Codicon.copy), true, () => this.createNewProfile(profileElement.profile)))));
+        const exportAction = disposables.add(( (new Action('userDataProfile.export', ( localizeWithPath(_moduleId, 7, "Export...")), ThemeIcon.asClassName(Codicon.export), true, () => this.exportProfile(profileElement.profile)))));
+        const deleteAction = disposables.add(( (new Action('userDataProfile.delete', ( localizeWithPath(_moduleId, 8, "Delete")), ThemeIcon.asClassName(Codicon.trash), true, () => this.removeProfile(profileElement.profile)))));
+        const newWindowAction = disposables.add(( (new Action('userDataProfile.newWindow', ( localizeWithPath(_moduleId, 9, "Open New Window with this Profile")), ThemeIcon.asClassName(Codicon.emptyWindow), true, () => this.openWindow(profileElement.profile)))));
+        const useAsNewWindowProfileAction = disposables.add(( (new Action('userDataProfile.useAsNewWindowProfile', ( localizeWithPath(_moduleId, 10, "Use for New Windows")), undefined, true, () => profileElement.toggleNewWindowProfile()))));
         const titlePrimaryActions = [];
-        titlePrimaryActions.push(activateAction);
-        titlePrimaryActions.push(exportAction);
-        if (!profile.isDefault) {
-            titlePrimaryActions.push(deleteAction);
-        }
+        titlePrimaryActions.push(newWindowAction);
         const titleSecondaryActions = [];
         titleSecondaryActions.push(copyFromProfileAction);
+        titleSecondaryActions.push(exportAction);
+        if (!profile.isDefault) {
+            titleSecondaryActions.push(( (new Separator())));
+            titleSecondaryActions.push(deleteAction);
+        }
+        const primaryActions = [];
+        primaryActions.push(newWindowAction);
         const secondaryActions = [];
         secondaryActions.push(activateAction);
+        secondaryActions.push(useAsNewWindowProfileAction);
         secondaryActions.push(( (new Separator())));
         secondaryActions.push(copyFromProfileAction);
         secondaryActions.push(exportAction);
@@ -391,17 +617,50 @@ let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends Edit
             secondaryActions.push(( (new Separator())));
             secondaryActions.push(deleteAction);
         }
-        const profileElement = disposables.add(this.instantiationService.createInstance(UserDataProfileElement, profile, [titlePrimaryActions, titleSecondaryActions], secondaryActions));
+        const profileElement = disposables.add(this.instantiationService.createInstance(UserDataProfileElement, profile, [[], []], [titlePrimaryActions, titleSecondaryActions], [primaryActions, secondaryActions]));
+        activateAction.checked = this.userDataProfileService.currentProfile.id === profileElement.profile.id;
+        disposables.add(this.userDataProfileService.onDidChangeCurrentProfile(() => activateAction.checked = this.userDataProfileService.currentProfile.id === profileElement.profile.id));
+        useAsNewWindowProfileAction.checked = profileElement.isNewWindowProfile;
+        disposables.add(profileElement.onDidChange(e => {
+            if (e.newWindowProfile) {
+                useAsNewWindowProfileAction.checked = profileElement.isNewWindowProfile;
+            }
+        }));
         return [profileElement, disposables];
     }
-    createNewProfile(copyFrom) {
+    async createNewProfile(copyFrom) {
+        if (this.newProfileElement) {
+            const result = await this.dialogService.confirm({
+                type: 'info',
+                message: ( localizeWithPath(
+                    _moduleId,
+                    11,
+                    "A new profile is already being created. Do you want to discard it and create a new one?"
+                )),
+                primaryButton: ( localizeWithPath(_moduleId, 12, "Discard & Create")),
+                cancelButton: ( localizeWithPath(_moduleId, 13, "Cancel"))
+            });
+            if (!result.confirmed) {
+                return;
+            }
+            this.revert();
+        }
         if (!this.newProfileElement) {
             const disposables = ( (new DisposableStore()));
-            const discardAction = disposables.add(( (new Action('userDataProfile.discard', ( localizeWithPath(_moduleId, 7, "Discard")), ThemeIcon.asClassName(Codicon.close), true, () => {
-                this.removeNewProfile();
-                this._onDidChange.fire(undefined);
-            }))));
-            this.newProfileElement = disposables.add(this.instantiationService.createInstance(NewProfileElement, ( localizeWithPath(_moduleId, 8, "Untitled")), copyFrom, disposables.add(( (new Action('userDataProfile.create', ( localizeWithPath(_moduleId, 9, "Create & Apply")), undefined, true, () => this.saveNewProfile())))), [[discardAction], []], [discardAction]));
+            const cancellationTokenSource = ( (new CancellationTokenSource()));
+            disposables.add(toDisposable(() => cancellationTokenSource.dispose(true)));
+            const createAction = disposables.add(( (new Action('userDataProfile.create', ( localizeWithPath(_moduleId, 14, "Create")), undefined, true, () => this.saveNewProfile(false, cancellationTokenSource.token)))));
+            const cancelAction = disposables.add(( (new Action('userDataProfile.cancel', ( localizeWithPath(_moduleId, 13, "Cancel")), ThemeIcon.asClassName(Codicon.trash), true, () => this.discardNewProfile()))));
+            const previewProfileAction = disposables.add(( (new Action('userDataProfile.preview', ( localizeWithPath(_moduleId, 15, "Preview")), ThemeIcon.asClassName(Codicon.openPreview), true, () => this.previewNewProfile(cancellationTokenSource.token)))));
+            this.newProfileElement = disposables.add(this.instantiationService.createInstance(NewProfileElement, copyFrom ? '' : ( localizeWithPath(_moduleId, 4, "Untitled")), copyFrom, [[createAction], [cancelAction, previewProfileAction]], [[], []], [[cancelAction], []]));
+            disposables.add(this.newProfileElement.onDidChange(e => {
+                if (e.preview) {
+                    previewProfileAction.checked = !!this.newProfileElement?.previewProfile;
+                }
+                if (e.disabled || e.message) {
+                    previewProfileAction.enabled = createAction.enabled = !this.newProfileElement?.disabled && !this.newProfileElement?.message;
+                }
+            }));
             this._profiles.push([this.newProfileElement, disposables]);
             this._onDidChange.fire(this.newProfileElement);
         }
@@ -417,55 +676,122 @@ let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends Edit
             this.newProfileElement = undefined;
         }
     }
-    async saveNewProfile() {
+    async previewNewProfile(token) {
         if (!this.newProfileElement) {
             return;
         }
+        if (this.newProfileElement.previewProfile) {
+            return;
+        }
+        const profile = await this.saveNewProfile(true, token);
+        if (profile) {
+            this.newProfileElement.previewProfile = profile;
+            await this.openWindow(profile);
+        }
+    }
+    async saveNewProfile(transient, token) {
+        if (!this.newProfileElement) {
+            return undefined;
+        }
         this.newProfileElement.validate();
         if (this.newProfileElement.message) {
+            return undefined;
+        }
+        this.newProfileElement.disabled = true;
+        let profile;
+        try {
+            if (this.newProfileElement.previewProfile) {
+                if (!transient) {
+                    profile = await this.userDataProfileManagementService.updateProfile(this.newProfileElement.previewProfile, { transient: false });
+                }
+            }
+            else {
+                const { flags, icon, name, copyFrom } = this.newProfileElement;
+                const useDefaultFlags = flags
+                    ? flags.settings && flags.keybindings && flags.tasks && flags.globalState && flags.extensions ? undefined : flags
+                    : undefined;
+                const createProfileTelemetryData = { source: copyFrom instanceof URI ? 'template' : isUserDataProfile(copyFrom) ? 'profile' : copyFrom ? 'external' : undefined };
+                if (copyFrom instanceof URI) {
+                    const template = await this.newProfileElement.resolveTemplate(copyFrom);
+                    if (template) {
+                        this.telemetryService.publicLog2('userDataProfile.createFromTemplate', createProfileTelemetryData);
+                        profile = await this.userDataProfileImportExportService.createProfileFromTemplate(template, {
+                            name,
+                            useDefaultFlags,
+                            icon,
+                            resourceTypeFlags: this.newProfileElement.copyFlags,
+                            transient
+                        }, token ?? CancellationToken.None);
+                    }
+                }
+                else if (isUserDataProfile(copyFrom)) {
+                    this.telemetryService.publicLog2('userDataProfile.createFromProfile', createProfileTelemetryData);
+                    profile = await this.userDataProfileImportExportService.createFromProfile(copyFrom, {
+                        name,
+                        useDefaultFlags,
+                        icon: icon,
+                        resourceTypeFlags: this.newProfileElement.copyFlags,
+                        transient
+                    }, token ?? CancellationToken.None);
+                }
+                else {
+                    this.telemetryService.publicLog2('userDataProfile.createEmptyProfile', createProfileTelemetryData);
+                    profile = await this.userDataProfileManagementService.createProfile(name, { useDefaultFlags, icon, transient });
+                }
+            }
+        }
+        finally {
+            if (this.newProfileElement) {
+                this.newProfileElement.disabled = false;
+            }
+        }
+        if (token?.isCancellationRequested) {
+            if (profile) {
+                try {
+                    await this.userDataProfileManagementService.removeProfile(profile);
+                }
+                catch (error) {
+                }
+            }
             return;
         }
-        const { flags, icon, name, copyFrom } = this.newProfileElement;
-        const useDefaultFlags = flags
-            ? flags.settings && flags.keybindings && flags.tasks && flags.globalState && flags.extensions ? undefined : flags
-            : undefined;
-        const createProfileTelemetryData = { source: copyFrom instanceof URI ? 'template' : isUserDataProfile(copyFrom) ? 'profile' : copyFrom ? 'external' : undefined };
-        if (copyFrom instanceof URI) {
-            this.telemetryService.publicLog2('userDataProfile.createFromTemplate', createProfileTelemetryData);
-            await this.userDataProfileImportExportService.importProfile(copyFrom, { mode: 'apply', name: name, useDefaultFlags, icon: icon ? icon : undefined, resourceTypeFlags: this.newProfileElement.copyFlags });
+        if (profile && !profile.isTransient && this.newProfileElement) {
+            this.removeNewProfile();
+            this.onDidChangeProfiles({ added: [profile], removed: [], updated: [], all: this.userDataProfilesService.profiles });
         }
-        else if (isUserDataProfile(copyFrom)) {
-            this.telemetryService.publicLog2('userDataProfile.createFromProfile', createProfileTelemetryData);
-            await this.userDataProfileImportExportService.createFromProfile(copyFrom, name, { useDefaultFlags, icon: icon ? icon : undefined, resourceTypeFlags: this.newProfileElement.copyFlags });
+        return profile;
+    }
+    async discardNewProfile() {
+        if (!this.newProfileElement) {
+            return;
         }
-        else {
-            this.telemetryService.publicLog2('userDataProfile.createEmptyProfile', createProfileTelemetryData);
-            await this.userDataProfileManagementService.createAndEnterProfile(name, { useDefaultFlags, icon: icon ? icon : undefined });
+        if (this.newProfileElement.previewProfile) {
+            await this.userDataProfileManagementService.removeProfile(this.newProfileElement.previewProfile);
         }
         this.removeNewProfile();
-        const profile = this.userDataProfilesService.profiles.find(p => p.name === name);
-        if (profile) {
-            this.onDidChangeProfiles({ added: [profile], removed: [], updated: [], all: this.userDataProfilesService.profiles });
-        }
+        this._onDidChange.fire(undefined);
     }
     async removeProfile(profile) {
         const result = await this.dialogService.confirm({
             type: 'info',
             message: ( localizeWithPath(
                 _moduleId,
-                10,
+                16,
                 "Are you sure you want to delete the profile '{0}'?",
                 profile.name
             )),
-            primaryButton: ( localizeWithPath(_moduleId, 6, "Delete")),
-            cancelButton: ( localizeWithPath(_moduleId, 11, "Cancel"))
+            primaryButton: ( localizeWithPath(_moduleId, 8, "Delete")),
+            cancelButton: ( localizeWithPath(_moduleId, 13, "Cancel"))
         });
         if (result.confirmed) {
             await this.userDataProfileManagementService.removeProfile(profile);
         }
     }
+    async openWindow(profile) {
+        await this.hostService.openWindow({ forceProfile: profile.name });
+    }
     async exportProfile(profile) {
-        return this.userDataProfileImportExportService.exportProfile2(profile);
+        return this.userDataProfileImportExportService.exportProfile(profile);
     }
 };
 UserDataProfilesEditorModel = UserDataProfilesEditorModel_1 = ( (__decorate([
@@ -475,7 +801,8 @@ UserDataProfilesEditorModel = UserDataProfilesEditorModel_1 = ( (__decorate([
     ( (__param(3, IUserDataProfileImportExportService))),
     ( (__param(4, IDialogService))),
     ( (__param(5, ITelemetryService))),
-    ( (__param(6, IInstantiationService)))
+    ( (__param(6, IHostService))),
+    ( (__param(7, IInstantiationService)))
 ], UserDataProfilesEditorModel)));
 
-export { AbstractUserDataProfileElement, NewProfileElement, UserDataProfileElement, UserDataProfilesEditorModel };
+export { AbstractUserDataProfileElement, NewProfileElement, UserDataProfileElement, UserDataProfilesEditorModel, isProfileResourceChildElement, isProfileResourceTypeElement };