@codingame/monaco-vscode-user-data-sync-service-override 1.85.2

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

@@ -0,0 +1,342 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { GlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionEnablementService';
+import { EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT, IExtensionManagementService, IExtensionGalleryService, IGlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IUserDataProfileStorageService } from '../../../../platform/userDataProfile/common/userDataProfileStorageService.js';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
+    constructor(userDataProfileService, extensionManagementService, extensionGalleryService, extensionEnablementService, logService) {
+        this.userDataProfileService = userDataProfileService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.logService = logService;
+    }
+    async initialize(content) {
+        const profileExtensions = JSON.parse(content);
+        const installedExtensions = await this.extensionManagementService.getInstalled(undefined, this.userDataProfileService.currentProfile.extensionsResource);
+        const extensionsToEnableOrDisable = [];
+        const extensionsToInstall = [];
+        for (const e of profileExtensions) {
+            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);
+            }
+            if (isDisabled !== !!e.disabled) {
+                extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+            }
+        }
+        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);
+                await this.extensionEnablementService.enableExtension(extension);
+                this.logService.info(`Initializing Profile: Enabled extension...`, extension.id);
+            }
+            else {
+                this.logService.trace(`Initializing Profile: Disabling extension...`, extension.id);
+                await this.extensionEnablementService.disableExtension(extension);
+                this.logService.info(`Initializing Profile: Disabled extension...`, extension.id);
+            }
+        }
+        if (extensionsToInstall.length) {
+            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) => {
+                const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
+                if (!extension) {
+                    return;
+                }
+                if (await this.extensionManagementService.canInstall(extension)) {
+                    this.logService.trace(`Initializing Profile: Installing extension...`, extension.identifier.id, extension.version);
+                    await this.extensionManagementService.installFromGallery(extension, {
+                        isMachineScoped: false,
+                        donotIncludePackAndDependencies: true,
+                        installGivenVersion: !!e.version,
+                        installPreReleaseVersion: e.preRelease,
+                        profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+                        context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true }
+                    });
+                    this.logService.info(`Initializing Profile: Installed extension...`, extension.identifier.id, extension.version);
+                }
+                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))));
+        }
+    }
+};
+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;
+        this.extensionGalleryService = extensionGalleryService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+    }
+    async getContent(profile, exclude) {
+        const extensions = await this.getLocalExtensions(profile);
+        return this.toContent(extensions, exclude);
+    }
+    toContent(extensions, exclude) {
+        return JSON.stringify(exclude?.length ? extensions.filter(e => !exclude.includes(e.identifier.id.toLowerCase())) : extensions);
+    }
+    async apply(content, profile) {
+        return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
+            const profileExtensions = await this.getProfileExtensions(content);
+            const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
+            const extensionsToEnableOrDisable = [];
+            const extensionsToInstall = [];
+            for (const e of profileExtensions) {
+                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);
+                }
+                if (isDisabled !== !!e.disabled) {
+                    extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+                }
+            }
+            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);
+                    await extensionEnablementService.enableExtension(extension);
+                    this.logService.info(`Importing Profile (${profile.name}): Enabled extension...`, extension.id);
+                }
+                else {
+                    this.logService.trace(`Importing Profile (${profile.name}): Disabling extension...`, extension.id);
+                    await extensionEnablementService.disableExtension(extension);
+                    this.logService.info(`Importing Profile (${profile.name}): Disabled extension...`, extension.id);
+                }
+            }
+            if (extensionsToInstall.length) {
+                this.logService.info(`Importing Profile (${profile.name}): Started installing extensions.`);
+                const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
+                    e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
+                )), CancellationToken.None);
+                const installExtensionInfos = [];
+                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)) {
+                        installExtensionInfos.push({
+                            extension,
+                            options: {
+                                isMachineScoped: false,
+                                donotIncludePackAndDependencies: true,
+                                installGivenVersion: !!e.version,
+                                installPreReleaseVersion: e.preRelease,
+                                profileLocation: profile.extensionsResource,
+                                context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true }
+                            }
+                        });
+                    }
+                    else {
+                        this.logService.info(`Importing Profile (${profile.name}): Skipped installing extension because it cannot be installed.`, extension.identifier.id);
+                    }
+                })));
+                if (installExtensionInfos.length) {
+                    await this.extensionManagementService.installGalleryExtensions(installExtensionInfos);
+                }
+                this.logService.info(`Importing Profile (${profile.name}): Finished installing extensions.`);
+            }
+            if (extensionsToUninstall.length) {
+                await Promise.all(( extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e))));
+            }
+        });
+    }
+    async copy(from, to, disableExtensions) {
+        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);
+            for (const extension of extensions) {
+                extensionsToDisable.push(extension.identifier);
+            }
+        }
+        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 = [];
+            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)));
+                if (extension.isBuiltin && !disabled) {
+                    continue;
+                }
+                if (!extension.isBuiltin) {
+                    if (!extension.identifier.uuid) {
+                        continue;
+                    }
+                }
+                const profileExtension = { identifier, displayName: extension.manifest.displayName };
+                if (disabled) {
+                    profileExtension.disabled = true;
+                }
+                if (!extension.isBuiltin && extension.pinned) {
+                    profileExtension.version = extension.manifest.version;
+                }
+                if (!profileExtension.version && preRelease) {
+                    profileExtension.preRelease = true;
+                }
+                result.push(profileExtension);
+            }
+            return result;
+        });
+    }
+    async getProfileExtensions(content) {
+        return JSON.parse(content);
+    }
+    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 extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
+            try {
+                return await fn(extensionEnablementService);
+            }
+            finally {
+                disposables.dispose();
+            }
+        });
+    }
+};
+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: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/extensionsResource',
+            'extensions',
+            "Extensions"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Expanded;
+        this.contextValue = "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 => ({
+            handle: e.identifier.id.toLowerCase(),
+            parent: this,
+            label: { label: e.displayName || e.identifier.id },
+            description: e.disabled ? ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                'disabled',
+                "Disabled"
+            )) : 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: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                    'exclude',
+                    "Select {0} Extension",
+                    e.displayName || e.identifier.id
+                )),
+                accessibilityInformation: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                        'exclude',
+                        "Select {0} Extension",
+                        e.displayName || e.identifier.id
+                    )),
+                }
+            } : undefined,
+            command: {
+                id: 'extension.open',
+                title: '',
+                arguments: [e.identifier.id, undefined, true]
+            }
+        })));
+    }
+    async hasContent() {
+        const extensions = await this.getExtensions();
+        return extensions.length > 0;
+    }
+}
+let ExtensionsResourceExportTreeItem = class ExtensionsResourceExportTreeItem extends ExtensionsResourceTreeItem {
+    constructor(profile, instantiationService) {
+        super();
+        this.profile = profile;
+        this.instantiationService = instantiationService;
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.extensions;
+    }
+    getExtensions() {
+        return this.instantiationService.createInstance(ExtensionsResource).getLocalExtensions(this.profile);
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(ExtensionsResource).getContent(this.profile, [...( this.excludedExtensions.values())]);
+    }
+};
+ExtensionsResourceExportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceExportTreeItem));
+let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem extends ExtensionsResourceTreeItem {
+    constructor(content, instantiationService) {
+        super();
+        this.content = content;
+        this.instantiationService = instantiationService;
+    }
+    isFromDefaultProfile() {
+        return false;
+    }
+    getExtensions() {
+        return this.instantiationService.createInstance(ExtensionsResource).getProfileExtensions(this.content);
+    }
+    async getContent() {
+        const extensionsResource = this.instantiationService.createInstance(ExtensionsResource);
+        const extensions = await extensionsResource.getProfileExtensions(this.content);
+        return extensionsResource.toContent(extensions, [...( this.excludedExtensions.values())]);
+    }
+};
+ExtensionsResourceImportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceImportTreeItem));
+
+export { ExtensionsResource, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem, ExtensionsResourceInitializer, ExtensionsResourceTreeItem };

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

@@ -0,0 +1,147 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IUserDataProfileStorageService } from '../../../../platform/userDataProfile/common/userDataProfileStorageService.js';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+
+let GlobalStateResourceInitializer = class GlobalStateResourceInitializer {
+    constructor(storageService) {
+        this.storageService = storageService;
+    }
+    async initialize(content) {
+        const globalState = JSON.parse(content);
+        const storageKeys = ( Object.keys(globalState.storage));
+        if (storageKeys.length) {
+            const storageEntries = [];
+            for (const key of storageKeys) {
+                storageEntries.push({ key, value: globalState.storage[key], scope: 0 , target: 0  });
+            }
+            this.storageService.storeAll(storageEntries, true);
+        }
+    }
+};
+GlobalStateResourceInitializer = ( __decorate([
+    ( __param(0, IStorageService))
+], GlobalStateResourceInitializer));
+let GlobalStateResource = class GlobalStateResource {
+    constructor(storageService, userDataProfileStorageService, logService) {
+        this.storageService = storageService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.logService = logService;
+    }
+    async getContent(profile) {
+        const globalState = await this.getGlobalState(profile);
+        return JSON.stringify(globalState);
+    }
+    async apply(content, profile) {
+        const globalState = JSON.parse(content);
+        await this.writeGlobalState(globalState, profile);
+    }
+    async getGlobalState(profile) {
+        const storage = {};
+        const storageData = await this.userDataProfileStorageService.readStorageData(profile);
+        for (const [key, value] of storageData) {
+            if (value.value !== undefined && value.target === 0 ) {
+                storage[key] = value.value;
+            }
+        }
+        return { storage };
+    }
+    async writeGlobalState(globalState, profile) {
+        const storageKeys = ( Object.keys(globalState.storage));
+        if (storageKeys.length) {
+            const updatedStorage = ( new Map());
+            const nonProfileKeys = [
+                ...( this.storageService.keys(-1, 1 )),
+                ...( this.storageService.keys(1, 0 )),
+                ...( this.storageService.keys(1, 1 )),
+            ];
+            for (const key of storageKeys) {
+                if (nonProfileKeys.includes(key)) {
+                    this.logService.info(`Importing Profile (${profile.name}): Ignoring global state key '${key}' because it is not a profile key.`);
+                }
+                else {
+                    updatedStorage.set(key, globalState.storage[key]);
+                }
+            }
+            await this.userDataProfileStorageService.updateStorageData(profile, updatedStorage, 0 );
+        }
+    }
+};
+GlobalStateResource = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IUserDataProfileStorageService)),
+    ( __param(2, ILogService))
+], GlobalStateResource));
+class GlobalStateResourceTreeItem {
+    constructor(resource, uriIdentityService) {
+        this.resource = resource;
+        this.uriIdentityService = uriIdentityService;
+        this.type = "globalState" ;
+        this.handle = "globalState" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/globalStateResource',
+            'globalState',
+            "UI State"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Collapsed;
+    }
+    async getChildren() {
+        return [{
+                handle: ( this.resource.toString()),
+                resourceUri: this.resource,
+                collapsibleState: TreeItemCollapsibleState.None,
+                accessibilityInformation: {
+                    label: this.uriIdentityService.extUri.basename(this.resource)
+                },
+                parent: this,
+                command: {
+                    id: API_OPEN_EDITOR_COMMAND_ID,
+                    title: '',
+                    arguments: [this.resource, undefined, undefined]
+                }
+            }];
+    }
+}
+let GlobalStateResourceExportTreeItem = class GlobalStateResourceExportTreeItem extends GlobalStateResourceTreeItem {
+    constructor(profile, resource, uriIdentityService, instantiationService) {
+        super(resource, uriIdentityService);
+        this.profile = profile;
+        this.instantiationService = instantiationService;
+    }
+    async hasContent() {
+        const globalState = await this.instantiationService.createInstance(GlobalStateResource).getGlobalState(this.profile);
+        return ( Object.keys(globalState.storage)).length > 0;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(GlobalStateResource).getContent(this.profile);
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.globalState;
+    }
+};
+GlobalStateResourceExportTreeItem = ( __decorate([
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IInstantiationService))
+], GlobalStateResourceExportTreeItem));
+let GlobalStateResourceImportTreeItem = class GlobalStateResourceImportTreeItem extends GlobalStateResourceTreeItem {
+    constructor(content, resource, uriIdentityService) {
+        super(resource, uriIdentityService);
+        this.content = content;
+    }
+    async getContent() {
+        return this.content;
+    }
+    isFromDefaultProfile() {
+        return false;
+    }
+};
+GlobalStateResourceImportTreeItem = ( __decorate([
+    ( __param(2, IUriIdentityService))
+], GlobalStateResourceImportTreeItem));
+
+export { GlobalStateResource, GlobalStateResourceExportTreeItem, GlobalStateResourceImportTreeItem, GlobalStateResourceInitializer, GlobalStateResourceTreeItem };

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

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { platform } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+
+let KeybindingsResourceInitializer = class KeybindingsResourceInitializer {
+    constructor(userDataProfileService, fileService, logService) {
+        this.userDataProfileService = userDataProfileService;
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async initialize(content) {
+        const keybindingsContent = JSON.parse(content);
+        if (keybindingsContent.keybindings === null) {
+            this.logService.info(`Initializing Profile: No keybindings to apply...`);
+            return;
+        }
+        await this.fileService.writeFile(this.userDataProfileService.currentProfile.keybindingsResource, VSBuffer.fromString(keybindingsContent.keybindings));
+    }
+};
+KeybindingsResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], KeybindingsResourceInitializer));
+let KeybindingsResource = class KeybindingsResource {
+    constructor(fileService, logService) {
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async getContent(profile) {
+        const keybindingsContent = await this.getKeybindingsResourceContent(profile);
+        return JSON.stringify(keybindingsContent);
+    }
+    async getKeybindingsResourceContent(profile) {
+        const keybindings = await this.getKeybindingsContent(profile);
+        return { keybindings, platform };
+    }
+    async apply(content, profile) {
+        const keybindingsContent = JSON.parse(content);
+        if (keybindingsContent.keybindings === null) {
+            this.logService.info(`Importing Profile (${profile.name}): No keybindings to apply...`);
+            return;
+        }
+        await this.fileService.writeFile(profile.keybindingsResource, VSBuffer.fromString(keybindingsContent.keybindings));
+    }
+    async getKeybindingsContent(profile) {
+        try {
+            const content = await this.fileService.readFile(profile.keybindingsResource);
+            return ( content.value.toString());
+        }
+        catch (error) {
+            if (error instanceof FileOperationError && error.fileOperationResult === 1 ) {
+                return null;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+};
+KeybindingsResource = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILogService))
+], KeybindingsResource));
+let KeybindingsResourceTreeItem = class KeybindingsResourceTreeItem {
+    constructor(profile, uriIdentityService, instantiationService) {
+        this.profile = profile;
+        this.uriIdentityService = uriIdentityService;
+        this.instantiationService = instantiationService;
+        this.type = "keybindings" ;
+        this.handle = "keybindings" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/keybindingsResource',
+            'keybindings',
+            "Keyboard Shortcuts"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Expanded;
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.keybindings;
+    }
+    async getChildren() {
+        return [{
+                handle: ( this.profile.keybindingsResource.toString()),
+                resourceUri: this.profile.keybindingsResource,
+                collapsibleState: TreeItemCollapsibleState.None,
+                parent: this,
+                accessibilityInformation: {
+                    label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
+                },
+                command: {
+                    id: API_OPEN_EDITOR_COMMAND_ID,
+                    title: '',
+                    arguments: [this.profile.keybindingsResource, undefined, undefined]
+                }
+            }];
+    }
+    async hasContent() {
+        const keybindingsContent = await this.instantiationService.createInstance(KeybindingsResource).getKeybindingsResourceContent(this.profile);
+        return keybindingsContent.keybindings !== null;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(KeybindingsResource).getContent(this.profile);
+    }
+};
+KeybindingsResourceTreeItem = ( __decorate([
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IInstantiationService))
+], KeybindingsResourceTreeItem));
+
+export { KeybindingsResource, KeybindingsResourceInitializer, KeybindingsResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/media/userDataProfileView.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".profile-view-tree-container .customview-tree .monaco-list .monaco-list-row .custom-view-tree-node-item .actions{display:inherit}.monaco-workbench .pane>.pane-body>.profile-view-message-container{box-sizing:border-box;display:flex;padding:13px 20px 0}.monaco-workbench .pane>.pane-body>.profile-view-message-container p{margin-block-end:0;margin-block-start:0}.monaco-workbench .pane>.pane-body>.profile-view-message-container a{color:var(--vscode-textLink-foreground)}.monaco-workbench .pane>.pane-body>.profile-view-message-container a:hover{color:var(--vscode-textLink-activeForeground);text-decoration:underline}.monaco-workbench .pane>.pane-body>.profile-view-message-container a:active{color:var(--vscode-textLink-activeForeground)}.monaco-workbench .pane>.pane-body>.profile-view-message-container.hide{display:none}.monaco-workbench .pane>.pane-body>.profile-view-buttons-container{box-sizing:border-box;display:flex;flex-direction:column;padding:13px 20px}.monaco-workbench .pane>.pane-body>.profile-view-buttons-container>.monaco-button,.monaco-workbench .pane>.pane-body>.profile-view-buttons-container>.monaco-button-dropdown{margin-block-start:13px;margin-inline-end:0;margin-inline-start:0;margin-left:auto;margin-right:auto;max-width:260px}.monaco-workbench .pane>.pane-body>.profile-view-buttons-container>.monaco-button-dropdown{width:100%}.monaco-workbench .pane>.pane-body>.profile-view-buttons-container>.monaco-button-dropdown>.monaco-dropdown-button{align-items:center;display:flex;padding:0 4px}.profile-edit-widget{padding:4px 6px 0 11px}.profile-edit-widget>.profile-icon-container{display:flex;margin-bottom:8px}.profile-edit-widget>.profile-icon-container>.profile-icon{border-radius:5px;cursor:pointer;padding:3px}.profile-edit-widget>.profile-icon-container>.profile-icon.codicon{font-size:18px}.profile-edit-widget>.profile-icon-container>.profile-icon:hover{background-color:var(--vscode-toolbar-hoverBackground);outline:1px dashed var(--vscode-toolbar-hoverOutline);outline-offset:-1px}.profile-edit-widget>.profile-type-container{align-items:center;display:flex;justify-content:space-between;margin-bottom:8px}.profile-edit-widget>.profile-icon-container>.profile-icon-label,.profile-edit-widget>.profile-type-container>.profile-type-create-label{align-items:center;display:inline-flex;width:90px}.profile-edit-widget>.profile-icon-container:only-child>.profile-icon-label{width:45px}.profile-edit-widget>.profile-icon-container>.profile-icon-id{align-items:center;display:inline-flex;font-size:.9em;margin-left:5px;opacity:.8}.profile-edit-widget>.profile-type-container>.profile-type-select-container{align-items:center;display:flex;flex:1;justify-content:center;overflow:hidden}.profile-edit-widget>.profile-type-container>.profile-type-select-container>.monaco-select-box{border-radius:2px;cursor:pointer;line-height:17px;padding:2px 23px 2px 8px}";
+n(css,{});
+
+export { css, css as default };