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

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

@@ -0,0 +1,481 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Action, Separator } from 'vscode/vscode/vs/base/common/actions';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+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 { 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 { 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';
+import { EditorModel } from 'vscode/vscode/vs/workbench/common/editor/editorModel';
+import { ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem } from '../../../services/userDataProfile/browser/extensionsResource.js';
+import { SettingsResourceTreeItem, SettingsResource } from '../../../services/userDataProfile/browser/settingsResource.js';
+import { KeybindingsResourceTreeItem, KeybindingsResource } from '../../../services/userDataProfile/browser/keybindingsResource.js';
+import { TasksResourceTreeItem, TasksResource } from '../../../services/userDataProfile/browser/tasksResource.js';
+import { SnippetsResourceTreeItem, SnippetsResource } from '../../../services/userDataProfile/browser/snippetsResource.js';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+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';
+
+var UserDataProfilesEditorModel_1;
+const _moduleId = "vs/workbench/contrib/userDataProfile/browser/userDataProfilesEditorModel";
+let AbstractUserDataProfileElement = class AbstractUserDataProfileElement extends Disposable {
+    constructor(name, icon, flags, isActive, userDataProfilesService, instantiationService) {
+        super();
+        this.userDataProfilesService = userDataProfilesService;
+        this.instantiationService = instantiationService;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this._name = '';
+        this._active = false;
+        this._name = name;
+        this._icon = icon;
+        this._flags = flags;
+        this._active = isActive;
+        this._register(this.onDidChange(e => {
+            if (!e.message) {
+                this.validate();
+            }
+            if (this.primaryAction) {
+                this.primaryAction.enabled = !this.message;
+            }
+        }));
+    }
+    get name() { return this._name; }
+    set name(label) {
+        if (this._name !== label) {
+            this._name = label;
+            this._onDidChange.fire({ name: true });
+        }
+    }
+    get icon() { return this._icon; }
+    set icon(icon) {
+        if (this._icon !== icon) {
+            this._icon = icon;
+            this._onDidChange.fire({ icon: true });
+        }
+    }
+    get flags() { return this._flags; }
+    set flags(flags) {
+        if (!equals(this._flags, flags)) {
+            this._flags = flags;
+            this._onDidChange.fire({ flags: true });
+        }
+    }
+    get active() { return this._active; }
+    set active(active) {
+        if (this._active !== active) {
+            this._active = active;
+            this._onDidChange.fire({ active: true });
+        }
+    }
+    get message() { return this._message; }
+    set message(message) {
+        if (this._message !== message) {
+            this._message = message;
+            this._onDidChange.fire({ message: true });
+        }
+    }
+    getFlag(key) {
+        return this.flags?.[key] ?? false;
+    }
+    setFlag(key, value) {
+        const flags = this.flags ? { ...this.flags } : {};
+        if (value) {
+            flags[key] = true;
+        }
+        else {
+            delete flags[key];
+        }
+        this.flags = flags;
+    }
+    validate() {
+        if (!this.name) {
+            this.message = ( localizeWithPath(_moduleId, 0, "Profile name is required."));
+            return;
+        }
+        if (this.name !== this.getInitialName() && ( (this.userDataProfilesService.profiles.some(p => p.name === this.name)))) {
+            this.message = ( localizeWithPath(_moduleId, 1, "Profile with name {0} already exists.", this.name));
+            return;
+        }
+        if (this.flags && this.flags.settings && this.flags.keybindings && this.flags.tasks && this.flags.snippets && this.flags.extensions) {
+            this.message = ( localizeWithPath(_moduleId, 2, "The profile should contain at least one configuration."));
+            return;
+        }
+        this.message = undefined;
+    }
+    async getChildren(resourceType) {
+        return [];
+    }
+    async getChildrenFromProfile(profile, resourceType) {
+        profile = this.getFlag(resourceType) ? this.userDataProfilesService.defaultProfile : profile;
+        switch (resourceType) {
+            case ProfileResourceType.Settings:
+                return this.instantiationService.createInstance(SettingsResourceTreeItem, profile).getChildren();
+            case ProfileResourceType.Keybindings:
+                return this.instantiationService.createInstance(KeybindingsResourceTreeItem, profile).getChildren();
+            case ProfileResourceType.Snippets:
+                return (await this.instantiationService.createInstance(SnippetsResourceTreeItem, profile).getChildren()) ?? [];
+            case ProfileResourceType.Tasks:
+                return this.instantiationService.createInstance(TasksResourceTreeItem, profile).getChildren();
+            case ProfileResourceType.Extensions:
+                return this.instantiationService.createInstance(ExtensionsResourceExportTreeItem, profile).getChildren();
+        }
+        return [];
+    }
+    getInitialName() {
+        return '';
+    }
+};
+AbstractUserDataProfileElement = ( (__decorate([
+    ( (__param(4, IUserDataProfilesService))),
+    ( (__param(5, 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);
+        this._profile = _profile;
+        this.titleActions = titleActions;
+        this.contextMenuActions = contextMenuActions;
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfileManagementService = userDataProfileManagementService;
+        this.primaryAction = undefined;
+        this.saveScheduler = this._register(( (new RunOnceScheduler(() => this.doSave(), 500))));
+        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);
+            if (profile) {
+                this._profile = profile;
+                this.name = profile.name;
+                this.icon = profile.icon;
+                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;
+        }
+        if (!equals(this.flags ?? {}, this.profile.useDefaultFlags ?? {})) {
+            return true;
+        }
+        return false;
+    }
+    save() {
+        this.saveScheduler.schedule();
+    }
+    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
+        });
+    }
+    async getChildren(resourceType) {
+        return this.getChildrenFromProfile(this.profile, resourceType);
+    }
+    getInitialName() {
+        return this.profile.name;
+    }
+};
+UserDataProfileElement = ( (__decorate([
+    ( (__param(3, IUserDataProfileService))),
+    ( (__param(4, IUserDataProfileManagementService))),
+    ( (__param(5, IUserDataProfilesService))),
+    ( (__param(6, 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;
+        this.titleActions = titleActions;
+        this.contextMenuActions = contextMenuActions;
+        this.fileService = fileService;
+        this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this._copyFrom = copyFrom;
+        this._copyFlags = this.getCopyFlagsFrom(copyFrom);
+        this._register(this.fileService.registerProvider(USER_DATA_PROFILE_TEMPLATE_PREVIEW_SCHEME, this._register(( (new InMemoryFileSystemProvider())))));
+    }
+    get copyFrom() { return this._copyFrom; }
+    set copyFrom(copyFrom) {
+        if (this._copyFrom !== copyFrom) {
+            this._copyFrom = copyFrom;
+            this._onDidChange.fire({ copyFrom: true });
+            this.flags = undefined;
+            this.copyFlags = this.getCopyFlagsFrom(copyFrom);
+        }
+    }
+    get copyFlags() { return this._copyFlags; }
+    set copyFlags(flags) {
+        if (!equals(this._copyFlags, flags)) {
+            this._copyFlags = flags;
+            this._onDidChange.fire({ copyFlags: true });
+        }
+    }
+    getCopyFlagsFrom(copyFrom) {
+        return copyFrom ? {
+            settings: true,
+            keybindings: true,
+            snippets: true,
+            tasks: true,
+            extensions: true
+        } : undefined;
+    }
+    getCopyFlag(key) {
+        return this.copyFlags?.[key] ?? false;
+    }
+    setCopyFlag(key, value) {
+        const flags = this.copyFlags ? { ...this.copyFlags } : {};
+        flags[key] = value;
+        this.copyFlags = flags;
+    }
+    async getChildren(resourceType) {
+        if (!this.getCopyFlag(resourceType)) {
+            return [];
+        }
+        if (this.copyFrom instanceof URI) {
+            const template = await this.userDataProfileImportExportService.resolveProfileTemplate(this.copyFrom);
+            if (!template) {
+                return [];
+            }
+            return this.getChildrenFromProfileTemplate(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) {
+        const profile = toUserDataProfile(generateUuid(), this.name, URI.file('/root').with({ scheme: USER_DATA_PROFILE_TEMPLATE_PREVIEW_SCHEME }), URI.file('/cache').with({ scheme: USER_DATA_PROFILE_TEMPLATE_PREVIEW_SCHEME }));
+        switch (resourceType) {
+            case ProfileResourceType.Settings:
+                if (profileTemplate.settings) {
+                    await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile);
+                }
+                return this.getChildrenFromProfile(profile, resourceType);
+            case ProfileResourceType.Keybindings:
+                if (profileTemplate.keybindings) {
+                    await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile);
+                }
+                return this.getChildrenFromProfile(profile, resourceType);
+            case ProfileResourceType.Snippets:
+                if (profileTemplate.snippets) {
+                    await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile);
+                }
+                return this.getChildrenFromProfile(profile, resourceType);
+            case ProfileResourceType.Tasks:
+                if (profileTemplate.tasks) {
+                    await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile);
+                }
+                return this.getChildrenFromProfile(profile, resourceType);
+            case ProfileResourceType.Extensions:
+                if (profileTemplate.extensions) {
+                    return this.instantiationService.createInstance(ExtensionsResourceImportTreeItem, profileTemplate.extensions).getChildren();
+                }
+        }
+        return [];
+    }
+};
+NewProfileElement = ( (__decorate([
+    ( (__param(5, IFileService))),
+    ( (__param(6, IUserDataProfileImportExportService))),
+    ( (__param(7, IUserDataProfilesService))),
+    ( (__param(8, IInstantiationService)))
+], NewProfileElement)));
+let UserDataProfilesEditorModel = class UserDataProfilesEditorModel extends EditorModel {
+    static { UserDataProfilesEditorModel_1 = this; }
+    static getInstance(instantiationService) {
+        if (!UserDataProfilesEditorModel_1.INSTANCE) {
+            UserDataProfilesEditorModel_1.INSTANCE = instantiationService.createInstance(UserDataProfilesEditorModel_1);
+        }
+        return UserDataProfilesEditorModel_1.INSTANCE;
+    }
+    get profiles() {
+        return ( (this._profiles
+            .map(([profile]) => profile)))
+            .sort((a, b) => {
+            if (a instanceof NewProfileElement) {
+                return 1;
+            }
+            if (b instanceof NewProfileElement) {
+                return -1;
+            }
+            if (a instanceof UserDataProfileElement && a.profile.isDefault) {
+                return -1;
+            }
+            if (b instanceof UserDataProfileElement && b.profile.isDefault) {
+                return 1;
+            }
+            return a.name.localeCompare(b.name);
+        });
+    }
+    constructor(userDataProfileService, userDataProfilesService, userDataProfileManagementService, userDataProfileImportExportService, dialogService, telemetryService, instantiationService) {
+        super();
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileManagementService = userDataProfileManagementService;
+        this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this.dialogService = dialogService;
+        this.telemetryService = telemetryService;
+        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));
+        }
+        this._register(toDisposable(() => ( (this._profiles.splice(0, this._profiles.length).map(([, disposables]) => disposables.dispose())))));
+        this._register(userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e)));
+    }
+    onDidChangeProfiles(e) {
+        for (const profile of e.added) {
+            if (profile.name !== this.newProfileElement?.name) {
+                this._profiles.push(this.createProfileElement(profile));
+            }
+        }
+        for (const profile of e.removed) {
+            this._profiles.findIndex(([p]) => p instanceof UserDataProfileElement && p.profile.id === profile.id);
+        }
+        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 titlePrimaryActions = [];
+        titlePrimaryActions.push(activateAction);
+        titlePrimaryActions.push(exportAction);
+        if (!profile.isDefault) {
+            titlePrimaryActions.push(deleteAction);
+        }
+        const titleSecondaryActions = [];
+        titleSecondaryActions.push(copyFromProfileAction);
+        const secondaryActions = [];
+        secondaryActions.push(activateAction);
+        secondaryActions.push(( (new Separator())));
+        secondaryActions.push(copyFromProfileAction);
+        secondaryActions.push(exportAction);
+        if (!profile.isDefault) {
+            secondaryActions.push(( (new Separator())));
+            secondaryActions.push(deleteAction);
+        }
+        const profileElement = disposables.add(this.instantiationService.createInstance(UserDataProfileElement, profile, [titlePrimaryActions, titleSecondaryActions], secondaryActions));
+        return [profileElement, disposables];
+    }
+    createNewProfile(copyFrom) {
+        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]));
+            this._profiles.push([this.newProfileElement, disposables]);
+            this._onDidChange.fire(this.newProfileElement);
+        }
+        return this.newProfileElement;
+    }
+    revert() {
+        this.removeNewProfile();
+        this._onDidChange.fire(undefined);
+    }
+    removeNewProfile() {
+        if (this.newProfileElement) {
+            this._profiles.findIndex(([p]) => p === this.newProfileElement);
+            this.newProfileElement = undefined;
+        }
+    }
+    async saveNewProfile() {
+        if (!this.newProfileElement) {
+            return;
+        }
+        this.newProfileElement.validate();
+        if (this.newProfileElement.message) {
+            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 });
+        }
+        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 });
+        }
+        else {
+            this.telemetryService.publicLog2('userDataProfile.createEmptyProfile', createProfileTelemetryData);
+            await this.userDataProfileManagementService.createAndEnterProfile(name, { useDefaultFlags, icon: icon ? icon : undefined });
+        }
+        this.removeNewProfile();
+        const profile = this.userDataProfilesService.profiles.find(p => p.name === name);
+        if (profile) {
+            this.onDidChangeProfiles({ added: [profile], removed: [], updated: [], all: this.userDataProfilesService.profiles });
+        }
+    }
+    async removeProfile(profile) {
+        const result = await this.dialogService.confirm({
+            type: 'info',
+            message: ( localizeWithPath(
+                _moduleId,
+                10,
+                "Are you sure you want to delete the profile '{0}'?",
+                profile.name
+            )),
+            primaryButton: ( localizeWithPath(_moduleId, 6, "Delete")),
+            cancelButton: ( localizeWithPath(_moduleId, 11, "Cancel"))
+        });
+        if (result.confirmed) {
+            await this.userDataProfileManagementService.removeProfile(profile);
+        }
+    }
+    async exportProfile(profile) {
+        return this.userDataProfileImportExportService.exportProfile2(profile);
+    }
+};
+UserDataProfilesEditorModel = UserDataProfilesEditorModel_1 = ( (__decorate([
+    ( (__param(0, IUserDataProfileService))),
+    ( (__param(1, IUserDataProfilesService))),
+    ( (__param(2, IUserDataProfileManagementService))),
+    ( (__param(3, IUserDataProfileImportExportService))),
+    ( (__param(4, IDialogService))),
+    ( (__param(5, ITelemetryService))),
+    ( (__param(6, IInstantiationService)))
+], UserDataProfilesEditorModel)));
+
+export { AbstractUserDataProfileElement, NewProfileElement, UserDataProfileElement, UserDataProfilesEditorModel };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { mark } from 'vscode/vscode/vs/base/common/performance';
@@ -56,7 +57,7 @@ InitializeOtherResourcesContribution = ( __decorate([
 ], InitializeOtherResourcesContribution));
 if (isWeb) {
     const workbenchRegistry = ( Registry.as(Extensions.Workbench));
-    workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, 3 );
+    workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, LifecyclePhase.Restored);
 }
 
 export { UserDataInitializationService };

package/vscode/src/vs/workbench/services/userDataProfile/browser/extensionsResource.js

@@ -6,10 +6,12 @@ import { GlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/exte
 import { EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
 import { IExtensionManagementService, IExtensionGalleryService, IGlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
 import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { ExtensionType } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ProfileResourceType } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
 import { IUserDataProfileStorageService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service';
 import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
@@ -175,7 +177,7 @@ let ExtensionsResource = class ExtensionsResource {
         await this.extensionManagementService.copyExtensions(from.extensionsResource, to.extensionsResource);
         const extensionsToDisable = await this.withProfileScopedServices(from, async (extensionEnablementService) => extensionEnablementService.getDisabledExtensions());
         if (disableExtensions) {
-            const extensions = await this.extensionManagementService.getInstalled(1 , to.extensionsResource);
+            const extensions = await this.extensionManagementService.getInstalled(ExtensionType.User, to.extensionsResource);
             for (const extension of extensions) {
                 extensionsToDisable.push(extension.identifier);
             }
@@ -184,7 +186,7 @@ let ExtensionsResource = class ExtensionsResource {
     }
     async getLocalExtensions(profile) {
         return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
-            const result = [];
+            const result = ( (new Map()));
             const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
             const disabledExtensions = extensionEnablementService.getDisabledExtensions();
             for (const extension of installedExtensions) {
@@ -198,6 +200,10 @@ let ExtensionsResource = class ExtensionsResource {
                         continue;
                     }
                 }
+                const existing = result.get(identifier.id.toLowerCase());
+                if (existing?.disabled) {
+                    result.delete(identifier.id.toLowerCase());
+                }
                 const profileExtension = { identifier, displayName: extension.manifest.displayName };
                 if (disabled) {
                     profileExtension.disabled = true;
@@ -208,9 +214,9 @@ let ExtensionsResource = class ExtensionsResource {
                 if (!profileExtension.version && preRelease) {
                     profileExtension.preRelease = true;
                 }
-                result.push(profileExtension);
+                result.set(profileExtension.identifier.id.toLowerCase(), profileExtension);
             }
-            return result;
+            return [...( (result.values()))];
         });
     }
     async getProfileExtensions(content) {
@@ -219,7 +225,7 @@ let ExtensionsResource = class ExtensionsResource {
     async withProfileScopedServices(profile, fn) {
         return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async (storageService) => {
             const disposables = ( (new DisposableStore()));
-            const instantiationService = this.instantiationService.createChild(( (new ServiceCollection([IStorageService, storageService]))));
+            const instantiationService = disposables.add(this.instantiationService.createChild(( (new ServiceCollection([IStorageService, storageService])))));
             const extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
             try {
                 return await fn(extensionEnablementService);
@@ -239,11 +245,11 @@ ExtensionsResource = ( (__decorate([
 ], ExtensionsResource)));
 class ExtensionsResourceTreeItem {
     constructor() {
-        this.type = "extensions" ;
-        this.handle = "extensions" ;
+        this.type = ProfileResourceType.Extensions;
+        this.handle = ProfileResourceType.Extensions;
         this.label = { label: ( localizeWithPath(_moduleId, 0, "Extensions")) };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
-        this.contextValue = "extensions" ;
+        this.contextValue = ProfileResourceType.Extensions;
         this.excludedExtensions = ( (new Set()));
     }
     async getChildren() {

package/vscode/src/vs/workbench/services/userDataProfile/browser/globalStateResource.js

@@ -2,8 +2,10 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ProfileResourceType } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
 import { IUserDataProfileStorageService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service';
 import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
 import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
@@ -19,7 +21,7 @@ let GlobalStateResourceInitializer = class GlobalStateResourceInitializer {
         if (storageKeys.length) {
             const storageEntries = [];
             for (const key of storageKeys) {
-                storageEntries.push({ key, value: globalState.storage[key], scope: 0 , target: 0  });
+                storageEntries.push({ key, value: globalState.storage[key], scope: StorageScope.PROFILE, target: StorageTarget.USER });
             }
             this.storageService.storeAll(storageEntries, true);
         }
@@ -46,7 +48,7 @@ let GlobalStateResource = class GlobalStateResource {
         const storage = {};
         const storageData = await this.userDataProfileStorageService.readStorageData(profile);
         for (const [key, value] of storageData) {
-            if (value.value !== undefined && value.target === 0 ) {
+            if (value.value !== undefined && value.target === StorageTarget.USER) {
                 storage[key] = value.value;
             }
         }
@@ -57,9 +59,9 @@ let GlobalStateResource = class GlobalStateResource {
         if (storageKeys.length) {
             const updatedStorage = ( (new Map()));
             const nonProfileKeys = [
-                ...( (this.storageService.keys(-1, 1 ))),
-                ...( (this.storageService.keys(1, 0 ))),
-                ...( (this.storageService.keys(1, 1 ))),
+                ...( (this.storageService.keys(StorageScope.APPLICATION, StorageTarget.MACHINE))),
+                ...( (this.storageService.keys(StorageScope.WORKSPACE, StorageTarget.USER))),
+                ...( (this.storageService.keys(StorageScope.WORKSPACE, StorageTarget.MACHINE))),
             ];
             for (const key of storageKeys) {
                 if (nonProfileKeys.includes(key)) {
@@ -69,7 +71,7 @@ let GlobalStateResource = class GlobalStateResource {
                     updatedStorage.set(key, globalState.storage[key]);
                 }
             }
-            await this.userDataProfileStorageService.updateStorageData(profile, updatedStorage, 0 );
+            await this.userDataProfileStorageService.updateStorageData(profile, updatedStorage, StorageTarget.USER);
         }
     }
 };
@@ -82,8 +84,8 @@ class GlobalStateResourceTreeItem {
     constructor(resource, uriIdentityService) {
         this.resource = resource;
         this.uriIdentityService = uriIdentityService;
-        this.type = "globalState" ;
-        this.handle = "globalState" ;
+        this.type = ProfileResourceType.GlobalState;
+        this.handle = ProfileResourceType.GlobalState;
         this.label = { label: ( localizeWithPath(_moduleId, 0, "UI State")) };
         this.collapsibleState = TreeItemCollapsibleState.Collapsed;
     }