@codingame/monaco-vscode-user-data-profile-service-override 11.1.2 → 12.0.1

package/vscode/src/vs/workbench/contrib/userDataProfile/common/userDataProfile.d.ts

@@ -0,0 +1,7 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IUserDataProfile } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { IEditorPane } from "vscode/vscode/vs/workbench/common/editor";
+export interface IUserDataProfilesEditor extends IEditorPane {
+    createNewProfile(copyFrom?: URI | IUserDataProfile): Promise<void>;
+    selectProfile(profile: IUserDataProfile): void;
+}

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.d.ts

@@ -0,0 +1,19 @@
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IUserDataInitializationService } from "vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service";
+export interface IUserDataInitializer {
+    requiresInitialization(): Promise<boolean>;
+    whenInitializationFinished(): Promise<void>;
+    initializeRequiredResources(): Promise<void>;
+    initializeInstalledExtensions(instantiationService: IInstantiationService): Promise<void>;
+    initializeOtherResources(instantiationService: IInstantiationService): Promise<void>;
+}
+export declare class UserDataInitializationService implements IUserDataInitializationService {
+    private readonly initializers;
+    _serviceBrand: any;
+    constructor(initializers?: IUserDataInitializer[]);
+    whenInitializationFinished(): Promise<void>;
+    requiresInitialization(): Promise<boolean>;
+    initializeRequiredResources(): Promise<void>;
+    initializeOtherResources(instantiationService: IInstantiationService): Promise<void>;
+    initializeInstalledExtensions(instantiationService: IInstantiationService): Promise<void>;
+}

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

@@ -1,7 +1,9 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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 +58,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.d.ts

@@ -0,0 +1,77 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IExtensionIdentifier } from "vscode/vscode/vs/platform/extensionManagement/common/extensionManagement";
+import { IGlobalExtensionEnablementService } from "vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IExtensionManagementService } from "vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IExtensionGalleryService } from "vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IUserDataProfile, ProfileResourceType } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { IUserDataProfileStorageService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service";
+import { ITreeItemCheckboxState, TreeItemCollapsibleState } from "vscode/vscode/vs/workbench/common/views";
+import { IProfileResource, IProfileResourceChildTreeItem, IProfileResourceInitializer, IProfileResourceTreeItem } from "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common/vscode/vs/workbench/services/userDataProfile/common/userDataProfile";
+import { IUserDataProfileService } from "vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+interface IProfileExtension {
+    identifier: IExtensionIdentifier;
+    displayName?: string;
+    preRelease?: boolean;
+    applicationScoped?: boolean;
+    disabled?: boolean;
+    version?: string;
+}
+export declare class ExtensionsResourceInitializer implements IProfileResourceInitializer {
+    private readonly userDataProfileService;
+    private readonly extensionManagementService;
+    private readonly extensionGalleryService;
+    private readonly extensionEnablementService;
+    private readonly logService;
+    constructor(userDataProfileService: IUserDataProfileService, extensionManagementService: IExtensionManagementService, extensionGalleryService: IExtensionGalleryService, extensionEnablementService: IGlobalExtensionEnablementService, logService: ILogService);
+    initialize(content: string): Promise<void>;
+}
+export declare class ExtensionsResource implements IProfileResource {
+    private readonly extensionManagementService;
+    private readonly extensionGalleryService;
+    private readonly userDataProfileStorageService;
+    private readonly instantiationService;
+    private readonly logService;
+    constructor(extensionManagementService: IExtensionManagementService, extensionGalleryService: IExtensionGalleryService, userDataProfileStorageService: IUserDataProfileStorageService, instantiationService: IInstantiationService, logService: ILogService);
+    getContent(profile: IUserDataProfile, exclude?: string[]): Promise<string>;
+    toContent(extensions: IProfileExtension[], exclude?: string[]): string;
+    apply(content: string, profile: IUserDataProfile, progress?: (message: string) => void, token?: CancellationToken): Promise<void>;
+    copy(from: IUserDataProfile, to: IUserDataProfile, disableExtensions: boolean): Promise<void>;
+    getLocalExtensions(profile: IUserDataProfile): Promise<IProfileExtension[]>;
+    getProfileExtensions(content: string): Promise<IProfileExtension[]>;
+    private withProfileScopedServices;
+}
+export declare abstract class ExtensionsResourceTreeItem implements IProfileResourceTreeItem {
+    readonly type = ProfileResourceType.Extensions;
+    readonly handle = ProfileResourceType.Extensions;
+    readonly label: {
+        label: string;
+    };
+    readonly collapsibleState = TreeItemCollapsibleState.Expanded;
+    contextValue: ProfileResourceType;
+    checkbox: ITreeItemCheckboxState | undefined;
+    protected readonly excludedExtensions: Set<string>;
+    getChildren(): Promise<Array<IProfileResourceChildTreeItem & IProfileExtension>>;
+    hasContent(): Promise<boolean>;
+    abstract isFromDefaultProfile(): boolean;
+    abstract getContent(): Promise<string>;
+    protected abstract getExtensions(): Promise<IProfileExtension[]>;
+}
+export declare class ExtensionsResourceExportTreeItem extends ExtensionsResourceTreeItem {
+    private readonly profile;
+    private readonly instantiationService;
+    constructor(profile: IUserDataProfile, instantiationService: IInstantiationService);
+    isFromDefaultProfile(): boolean;
+    protected getExtensions(): Promise<IProfileExtension[]>;
+    getContent(): Promise<string>;
+}
+export declare class ExtensionsResourceImportTreeItem extends ExtensionsResourceTreeItem {
+    private readonly content;
+    private readonly instantiationService;
+    constructor(content: string, instantiationService: IInstantiationService);
+    isFromDefaultProfile(): boolean;
+    protected getExtensions(): Promise<IProfileExtension[]>;
+    getContent(): Promise<string>;
+}
+export {};

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

@@ -1,16 +1,19 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
-import { GlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionEnablementService';
+import { GlobalExtensionEnablementService } from '@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/extensionManagement/common/extensionEnablementService';
 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';
@@ -29,7 +32,7 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
         const extensionsToEnableOrDisable = [];
         const extensionsToInstall = [];
         for (const e of profileExtensions) {
-            const isDisabled = ( (this.extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier))));
+            const isDisabled = ( this.extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
             const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));
             if (!installedExtension || (!installedExtension.isBuiltin && installedExtension.preRelease !== e.preRelease)) {
                 extensionsToInstall.push(e);
@@ -38,7 +41,7 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
                 extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
             }
         }
-        const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( (profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier)))));
+        const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))));
         for (const { extension, enable } of extensionsToEnableOrDisable) {
             if (enable) {
                 this.logService.trace(`Initializing Profile: Enabling extension...`, extension.id);
@@ -52,15 +55,15 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
             }
         }
         if (extensionsToInstall.length) {
-            const galleryExtensions = await this.extensionGalleryService.getExtensions(( (extensionsToInstall.map(
+            const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
                 e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
-            ))), CancellationToken.None);
-            await Promise.all(( (extensionsToInstall.map(async (e) => {
+            )), CancellationToken.None);
+            await Promise.all(( extensionsToInstall.map(async (e) => {
                 const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
                 if (!extension) {
                     return;
                 }
-                if (await this.extensionManagementService.canInstall(extension)) {
+                if ((await this.extensionManagementService.canInstall(extension)) === true) {
                     this.logService.trace(`Initializing Profile: Installing extension...`, extension.identifier.id, extension.version);
                     await this.extensionManagementService.installFromGallery(extension, {
                         isMachineScoped: false,
@@ -75,20 +78,20 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
                 else {
                     this.logService.info(`Initializing Profile: Skipped installing extension because it cannot be installed.`, extension.identifier.id);
                 }
-            }))));
+            })));
         }
         if (extensionsToUninstall.length) {
-            await Promise.all(( (extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e)))));
+            await Promise.all(( extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e))));
         }
     }
 };
-ExtensionsResourceInitializer = ( (__decorate([
-    ( (__param(0, IUserDataProfileService))),
-    ( (__param(1, IExtensionManagementService))),
-    ( (__param(2, IExtensionGalleryService))),
-    ( (__param(3, IGlobalExtensionEnablementService))),
-    ( (__param(4, ILogService)))
-], ExtensionsResourceInitializer)));
+ExtensionsResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, IGlobalExtensionEnablementService)),
+    ( __param(4, ILogService))
+], ExtensionsResourceInitializer));
 let ExtensionsResource = class ExtensionsResource {
     constructor(extensionManagementService, extensionGalleryService, userDataProfileStorageService, instantiationService, logService) {
         this.extensionManagementService = extensionManagementService;
@@ -111,7 +114,7 @@ let ExtensionsResource = class ExtensionsResource {
             const extensionsToEnableOrDisable = [];
             const extensionsToInstall = [];
             for (const e of profileExtensions) {
-                const isDisabled = ( (extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier))));
+                const isDisabled = ( extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
                 const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));
                 if (!installedExtension || (!installedExtension.isBuiltin && installedExtension.preRelease !== e.preRelease)) {
                     extensionsToInstall.push(e);
@@ -120,7 +123,7 @@ let ExtensionsResource = class ExtensionsResource {
                     extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
                 }
             }
-            const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( (profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier)))) && !extension.isApplicationScoped);
+            const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))) && !extension.isApplicationScoped);
             for (const { extension, enable } of extensionsToEnableOrDisable) {
                 if (enable) {
                     this.logService.trace(`Importing Profile (${profile.name}): Enabling extension...`, extension.id);
@@ -135,16 +138,16 @@ let ExtensionsResource = class ExtensionsResource {
             }
             if (extensionsToInstall.length) {
                 this.logService.info(`Importing Profile (${profile.name}): Started installing extensions.`);
-                const galleryExtensions = await this.extensionGalleryService.getExtensions(( (extensionsToInstall.map(
+                const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
                     e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
-                ))), CancellationToken.None);
+                )), CancellationToken.None);
                 const installExtensionInfos = [];
-                await Promise.all(( (extensionsToInstall.map(async (e) => {
+                await Promise.all(( extensionsToInstall.map(async (e) => {
                     const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
                     if (!extension) {
                         return;
                     }
-                    if (await this.extensionManagementService.canInstall(extension)) {
+                    if ((await this.extensionManagementService.canInstall(extension)) === true) {
                         installExtensionInfos.push({
                             extension,
                             options: {
@@ -160,7 +163,7 @@ let ExtensionsResource = class ExtensionsResource {
                     else {
                         this.logService.info(`Importing Profile (${profile.name}): Skipped installing extension because it cannot be installed.`, extension.identifier.id);
                     }
-                }))));
+                })));
                 if (installExtensionInfos.length) {
                     if (token) {
                         for (const installExtensionInfo of installExtensionInfos) {
@@ -168,7 +171,7 @@ let ExtensionsResource = class ExtensionsResource {
                                 return;
                             }
                             progress?.(( localize(
-                                9002,
+                                11973,
                                 "Installing extension {0}...",
                                 installExtensionInfo.extension.displayName ?? installExtensionInfo.extension.identifier.id
                             )));
@@ -182,7 +185,7 @@ let ExtensionsResource = class ExtensionsResource {
                 this.logService.info(`Importing Profile (${profile.name}): Finished installing extensions.`);
             }
             if (extensionsToUninstall.length) {
-                await Promise.all(( (extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e)))));
+                await Promise.all(( extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e))));
             }
         });
     }
@@ -190,21 +193,21 @@ 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);
             }
         }
-        await this.withProfileScopedServices(to, async (extensionEnablementService) => Promise.all(( (extensionsToDisable.map(extension => extensionEnablementService.disableExtension(extension))))));
+        await this.withProfileScopedServices(to, async (extensionEnablementService) => Promise.all(( extensionsToDisable.map(extension => extensionEnablementService.disableExtension(extension)))));
     }
     async getLocalExtensions(profile) {
         return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
-            const result = ( (new Map()));
+            const result = ( new Map());
             const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
             const disabledExtensions = extensionEnablementService.getDisabledExtensions();
             for (const extension of installedExtensions) {
                 const { identifier, preRelease } = extension;
-                const disabled = ( (disabledExtensions.some(disabledExtension => areSameExtensions(disabledExtension, identifier))));
+                const disabled = ( disabledExtensions.some(disabledExtension => areSameExtensions(disabledExtension, identifier)));
                 if (extension.isBuiltin && !disabled) {
                     continue;
                 }
@@ -230,7 +233,7 @@ let ExtensionsResource = class ExtensionsResource {
                 profileExtension.applicationScoped = extension.isApplicationScoped;
                 result.set(profileExtension.identifier.id.toLowerCase(), profileExtension);
             }
-            return [...( (result.values()))];
+            return [...( result.values())];
         });
     }
     async getProfileExtensions(content) {
@@ -238,8 +241,8 @@ let ExtensionsResource = class ExtensionsResource {
     }
     async withProfileScopedServices(profile, fn) {
         return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async (storageService) => {
-            const disposables = ( (new DisposableStore()));
-            const instantiationService = disposables.add(this.instantiationService.createChild(( (new ServiceCollection([IStorageService, storageService])))));
+            const disposables = ( new DisposableStore());
+            const instantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IStorageService, storageService]))));
             const extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
             try {
                 return await fn(extensionEnablementService);
@@ -250,56 +253,54 @@ let ExtensionsResource = class ExtensionsResource {
         });
     }
 };
-ExtensionsResource = ( (__decorate([
-    ( (__param(0, IExtensionManagementService))),
-    ( (__param(1, IExtensionGalleryService))),
-    ( (__param(2, IUserDataProfileStorageService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, ILogService)))
-], ExtensionsResource)));
+ExtensionsResource = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, IExtensionGalleryService)),
+    ( __param(2, IUserDataProfileStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService))
+], ExtensionsResource));
 class ExtensionsResourceTreeItem {
     constructor() {
-        this.type = "extensions" ;
-        this.handle = "extensions" ;
-        this.label = { label: ( localize(9003, "Extensions")) };
+        this.type = ProfileResourceType.Extensions;
+        this.handle = ProfileResourceType.Extensions;
+        this.label = { label: ( localize(11974, "Extensions")) };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
-        this.contextValue = "extensions" ;
-        this.excludedExtensions = ( (new Set()));
+        this.contextValue = ProfileResourceType.Extensions;
+        this.excludedExtensions = ( new Set());
     }
     async getChildren() {
         const extensions = (await this.getExtensions()).sort((a, b) => (a.displayName ?? a.identifier.id).localeCompare(b.displayName ?? b.identifier.id));
         const that = this;
-        return (
-             (extensions.map(e => ({
-                ...e,
-                handle: e.identifier.id.toLowerCase(),
-                parent: this,
-                label: { label: e.displayName || e.identifier.id },
-                description: e.applicationScoped ? ( localize(9004, "All Profiles")) : undefined,
-                collapsibleState: TreeItemCollapsibleState.None,
-                checkbox: that.checkbox ? {
-                    get isChecked() { return !( (that.excludedExtensions.has(e.identifier.id.toLowerCase()))); },
-                    set isChecked(value) {
-                        if (value) {
-                            that.excludedExtensions.delete(e.identifier.id.toLowerCase());
-                        }
-                        else {
-                            that.excludedExtensions.add(e.identifier.id.toLowerCase());
-                        }
-                    },
-                    tooltip: ( localize(9005, "Select {0} Extension", e.displayName || e.identifier.id)),
-                    accessibilityInformation: {
-                        label: ( localize(9005, "Select {0} Extension", e.displayName || e.identifier.id)),
+        return (extensions.map(e => ({
+            ...e,
+            handle: e.identifier.id.toLowerCase(),
+            parent: this,
+            label: { label: e.displayName || e.identifier.id },
+            description: e.applicationScoped ? ( localize(11975, "All Profiles")) : undefined,
+            collapsibleState: TreeItemCollapsibleState.None,
+            checkbox: that.checkbox ? {
+                get isChecked() { return !( that.excludedExtensions.has(e.identifier.id.toLowerCase())); },
+                set isChecked(value) {
+                    if (value) {
+                        that.excludedExtensions.delete(e.identifier.id.toLowerCase());
                     }
-                } : undefined,
-                themeIcon: Codicon.extensions,
-                command: {
-                    id: 'extension.open',
-                    title: '',
-                    arguments: [e.identifier.id, undefined, true]
+                    else {
+                        that.excludedExtensions.add(e.identifier.id.toLowerCase());
+                    }
+                },
+                tooltip: ( localize(11976, "Select {0} Extension", e.displayName || e.identifier.id)),
+                accessibilityInformation: {
+                    label: ( localize(11976, "Select {0} Extension", e.displayName || e.identifier.id)),
                 }
-            })))
-        );
+            } : undefined,
+            themeIcon: Codicon.extensions,
+            command: {
+                id: 'extension.open',
+                title: '',
+                arguments: [e.identifier.id, undefined, true]
+            }
+        })));
     }
     async hasContent() {
         const extensions = await this.getExtensions();
@@ -319,12 +320,12 @@ let ExtensionsResourceExportTreeItem = class ExtensionsResourceExportTreeItem ex
         return this.instantiationService.createInstance(ExtensionsResource).getLocalExtensions(this.profile);
     }
     async getContent() {
-        return this.instantiationService.createInstance(ExtensionsResource).getContent(this.profile, [...( (this.excludedExtensions.values()))]);
+        return this.instantiationService.createInstance(ExtensionsResource).getContent(this.profile, [...( this.excludedExtensions.values())]);
     }
 };
-ExtensionsResourceExportTreeItem = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], ExtensionsResourceExportTreeItem)));
+ExtensionsResourceExportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceExportTreeItem));
 let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem extends ExtensionsResourceTreeItem {
     constructor(content, instantiationService) {
         super();
@@ -340,11 +341,11 @@ let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem ex
     async getContent() {
         const extensionsResource = this.instantiationService.createInstance(ExtensionsResource);
         const extensions = await extensionsResource.getProfileExtensions(this.content);
-        return extensionsResource.toContent(extensions, [...( (this.excludedExtensions.values()))]);
+        return extensionsResource.toContent(extensions, [...( this.excludedExtensions.values())]);
     }
 };
-ExtensionsResourceImportTreeItem = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], ExtensionsResourceImportTreeItem)));
+ExtensionsResourceImportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceImportTreeItem));
 
 export { ExtensionsResource, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem, ExtensionsResourceInitializer, ExtensionsResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/globalStateResource.d.ts

@@ -0,0 +1,58 @@
+import { IStringDictionary } from "vscode/vscode/vs/base/common/collections";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IUserDataProfile, ProfileResourceType } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { IUserDataProfileStorageService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service";
+import { ITreeItemCheckboxState, TreeItemCollapsibleState } from "vscode/vscode/vs/workbench/common/views";
+import { IProfileResource, IProfileResourceChildTreeItem, IProfileResourceInitializer, IProfileResourceTreeItem } from "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common/vscode/vs/workbench/services/userDataProfile/common/userDataProfile";
+interface IGlobalState {
+    storage: IStringDictionary<string>;
+}
+export declare class GlobalStateResourceInitializer implements IProfileResourceInitializer {
+    private readonly storageService;
+    constructor(storageService: IStorageService);
+    initialize(content: string): Promise<void>;
+}
+export declare class GlobalStateResource implements IProfileResource {
+    private readonly storageService;
+    private readonly userDataProfileStorageService;
+    private readonly logService;
+    constructor(storageService: IStorageService, userDataProfileStorageService: IUserDataProfileStorageService, logService: ILogService);
+    getContent(profile: IUserDataProfile): Promise<string>;
+    apply(content: string, profile: IUserDataProfile): Promise<void>;
+    getGlobalState(profile: IUserDataProfile): Promise<IGlobalState>;
+    private writeGlobalState;
+}
+export declare abstract class GlobalStateResourceTreeItem implements IProfileResourceTreeItem {
+    private readonly resource;
+    private readonly uriIdentityService;
+    readonly type = ProfileResourceType.GlobalState;
+    readonly handle = ProfileResourceType.GlobalState;
+    readonly label: {
+        label: string;
+    };
+    readonly collapsibleState = TreeItemCollapsibleState.Collapsed;
+    checkbox: ITreeItemCheckboxState | undefined;
+    constructor(resource: URI, uriIdentityService: IUriIdentityService);
+    getChildren(): Promise<IProfileResourceChildTreeItem[]>;
+    abstract getContent(): Promise<string>;
+    abstract isFromDefaultProfile(): boolean;
+}
+export declare class GlobalStateResourceExportTreeItem extends GlobalStateResourceTreeItem {
+    private readonly profile;
+    private readonly instantiationService;
+    constructor(profile: IUserDataProfile, resource: URI, uriIdentityService: IUriIdentityService, instantiationService: IInstantiationService);
+    hasContent(): Promise<boolean>;
+    getContent(): Promise<string>;
+    isFromDefaultProfile(): boolean;
+}
+export declare class GlobalStateResourceImportTreeItem extends GlobalStateResourceTreeItem {
+    private readonly content;
+    constructor(content: string, resource: URI, uriIdentityService: IUriIdentityService);
+    getContent(): Promise<string>;
+    isFromDefaultProfile(): boolean;
+}
+export {};