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

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

@@ -0,0 +1,151 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { Barrier, Promises } from 'vscode/vscode/vs/base/common/async';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { SettingsResourceInitializer } from './settingsResource.js';
+import { GlobalStateResourceInitializer } from './globalStateResource.js';
+import { KeybindingsResourceInitializer } from './keybindingsResource.js';
+import { TasksResourceInitializer } from './tasksResource.js';
+import { SnippetsResourceInitializer } from './snippetsResource.js';
+import { ExtensionsResourceInitializer } from './extensionsResource.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { isString } from 'vscode/vscode/vs/base/common/types';
+import { asJson } from 'vscode/vscode/vs/platform/request/common/request';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+let UserDataProfileInitializer = class UserDataProfileInitializer {
+    constructor(environmentService, fileService, userDataProfileService, storageService, logService, uriIdentityService, requestService) {
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.userDataProfileService = userDataProfileService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.uriIdentityService = uriIdentityService;
+        this.requestService = requestService;
+        this.initialized = [];
+        this.initializationFinished = ( new Barrier());
+    }
+    async whenInitializationFinished() {
+        await this.initializationFinished.wait();
+    }
+    async requiresInitialization() {
+        if (!this.environmentService.options?.profile?.contents) {
+            return false;
+        }
+        if (!this.storageService.isNew(0 )) {
+            return false;
+        }
+        return true;
+    }
+    async initializeRequiredResources() {
+        this.logService.trace(`UserDataProfileInitializer#initializeRequiredResources`);
+        const promises = [];
+        const profileTemplate = await this.getProfileTemplate();
+        if (profileTemplate?.settings) {
+            promises.push(this.initialize(( new SettingsResourceInitializer(this.userDataProfileService, this.fileService, this.logService)), profileTemplate.settings, "settings" ));
+        }
+        if (profileTemplate?.globalState) {
+            promises.push(this.initialize(( new GlobalStateResourceInitializer(this.storageService)), profileTemplate.globalState, "globalState" ));
+        }
+        await Promise.all(promises);
+    }
+    async initializeOtherResources(instantiationService) {
+        try {
+            this.logService.trace(`UserDataProfileInitializer#initializeOtherResources`);
+            const promises = [];
+            const profileTemplate = await this.getProfileTemplate();
+            if (profileTemplate?.keybindings) {
+                promises.push(this.initialize(( new KeybindingsResourceInitializer(this.userDataProfileService, this.fileService, this.logService)), profileTemplate.keybindings, "keybindings" ));
+            }
+            if (profileTemplate?.tasks) {
+                promises.push(this.initialize(( new TasksResourceInitializer(this.userDataProfileService, this.fileService, this.logService)), profileTemplate.tasks, "tasks" ));
+            }
+            if (profileTemplate?.snippets) {
+                promises.push(this.initialize(( new SnippetsResourceInitializer(this.userDataProfileService, this.fileService, this.uriIdentityService)), profileTemplate.snippets, "snippets" ));
+            }
+            promises.push(this.initializeInstalledExtensions(instantiationService));
+            await Promises.settled(promises);
+        }
+        finally {
+            this.initializationFinished.open();
+        }
+    }
+    async initializeInstalledExtensions(instantiationService) {
+        if (!this.initializeInstalledExtensionsPromise) {
+            const profileTemplate = await this.getProfileTemplate();
+            if (profileTemplate?.extensions) {
+                this.initializeInstalledExtensionsPromise = this.initialize(instantiationService.createInstance(ExtensionsResourceInitializer), profileTemplate.extensions, "extensions" );
+            }
+            else {
+                this.initializeInstalledExtensionsPromise = Promise.resolve();
+            }
+        }
+        return this.initializeInstalledExtensionsPromise;
+    }
+    getProfileTemplate() {
+        if (!this.profileTemplatePromise) {
+            this.profileTemplatePromise = this.doGetProfileTemplate();
+        }
+        return this.profileTemplatePromise;
+    }
+    async doGetProfileTemplate() {
+        if (!this.environmentService.options?.profile?.contents) {
+            return null;
+        }
+        if (isString(this.environmentService.options.profile.contents)) {
+            try {
+                return JSON.parse(this.environmentService.options.profile.contents);
+            }
+            catch (error) {
+                this.logService.error(error);
+                return null;
+            }
+        }
+        try {
+            const url = ( URI.revive(this.environmentService.options.profile.contents).toString(true));
+            const context = await this.requestService.request({ type: 'GET', url }, CancellationToken.None);
+            if (context.res.statusCode === 200) {
+                return await asJson(context);
+            }
+            else {
+                this.logService.warn(`UserDataProfileInitializer: Failed to get profile from URL: ${url}. Status code: ${context.res.statusCode}.`);
+            }
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return null;
+    }
+    async initialize(initializer, content, profileResource) {
+        try {
+            if (this.initialized.includes(profileResource)) {
+                this.logService.info(`UserDataProfileInitializer: ${profileResource} initialized already.`);
+                return;
+            }
+            this.initialized.push(profileResource);
+            this.logService.trace(`UserDataProfileInitializer: Initializing ${profileResource}`);
+            await initializer.initialize(content);
+            this.logService.info(`UserDataProfileInitializer: Initialized ${profileResource}`);
+        }
+        catch (error) {
+            this.logService.info(`UserDataProfileInitializer: Error while initializing ${profileResource}`);
+            this.logService.error(error);
+        }
+    }
+};
+UserDataProfileInitializer = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUserDataProfileService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IUriIdentityService)),
+    ( __param(6, IRequestService))
+], UserDataProfileInitializer));
+
+export { UserDataProfileInitializer };

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

@@ -0,0 +1,180 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { equals } from 'vscode/vscode/vs/base/common/objects';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { asJson } from 'vscode/vscode/vs/platform/request/common/request';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { toWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+
+const _moduleId = "vs/workbench/services/userDataProfile/browser/userDataProfileManagement";
+let UserDataProfileManagementService = class UserDataProfileManagementService extends Disposable {
+    constructor(userDataProfilesService, userDataProfileService, hostService, dialogService, workspaceContextService, extensionService, environmentService, telemetryService, productService, requestService, logService) {
+        super();
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileService = userDataProfileService;
+        this.hostService = hostService;
+        this.dialogService = dialogService;
+        this.workspaceContextService = workspaceContextService;
+        this.extensionService = extensionService;
+        this.environmentService = environmentService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.requestService = requestService;
+        this.logService = logService;
+        this._register(userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e)));
+        this._register(userDataProfilesService.onDidResetWorkspaces(() => this.onDidResetWorkspaces()));
+        this._register(userDataProfileService.onDidChangeCurrentProfile(e => this.onDidChangeCurrentProfile(e)));
+        this._register(userDataProfilesService.onDidChangeProfiles(e => {
+            const updatedCurrentProfile = e.updated.find(p => this.userDataProfileService.currentProfile.id === p.id);
+            if (updatedCurrentProfile) {
+                this.changeCurrentProfile(updatedCurrentProfile, ( localizeWithPath(
+                    _moduleId,
+                    0,
+                    "The current profile has been updated. Please reload to switch back to the updated profile"
+                )));
+            }
+        }));
+    }
+    onDidChangeProfiles(e) {
+        if (( (e.removed.some(profile => profile.id === this.userDataProfileService.currentProfile.id)))) {
+            this.changeCurrentProfile(this.userDataProfilesService.defaultProfile, ( localizeWithPath(
+                _moduleId,
+                1,
+                "The current profile has been removed. Please reload to switch back to default profile"
+            )));
+            return;
+        }
+    }
+    onDidResetWorkspaces() {
+        if (!this.userDataProfileService.currentProfile.isDefault) {
+            this.changeCurrentProfile(this.userDataProfilesService.defaultProfile, ( localizeWithPath(
+                _moduleId,
+                1,
+                "The current profile has been removed. Please reload to switch back to default profile"
+            )));
+            return;
+        }
+    }
+    async onDidChangeCurrentProfile(e) {
+        if (e.previous.isTransient) {
+            await this.userDataProfilesService.cleanUpTransientProfiles();
+        }
+    }
+    async createAndEnterProfile(name, options) {
+        const profile = await this.userDataProfilesService.createNamedProfile(name, options, toWorkspaceIdentifier(this.workspaceContextService.getWorkspace()));
+        await this.changeCurrentProfile(profile);
+        this.telemetryService.publicLog2('profileManagementActionExecuted', { id: 'createAndEnterProfile' });
+        return profile;
+    }
+    async createAndEnterTransientProfile() {
+        const profile = await this.userDataProfilesService.createTransientProfile(toWorkspaceIdentifier(this.workspaceContextService.getWorkspace()));
+        await this.changeCurrentProfile(profile);
+        this.telemetryService.publicLog2('profileManagementActionExecuted', { id: 'createAndEnterTransientProfile' });
+        return profile;
+    }
+    async updateProfile(profile, updateOptions) {
+        if (!( (this.userDataProfilesService.profiles.some(p => p.id === profile.id)))) {
+            throw ( (new Error(`Profile ${profile.name} does not exist`)));
+        }
+        if (profile.isDefault) {
+            throw ( (new Error(localizeWithPath(_moduleId, 2, "Cannot rename the default profile"))));
+        }
+        await this.userDataProfilesService.updateProfile(profile, updateOptions);
+        this.telemetryService.publicLog2('profileManagementActionExecuted', { id: 'updateProfile' });
+    }
+    async removeProfile(profile) {
+        if (!( (this.userDataProfilesService.profiles.some(p => p.id === profile.id)))) {
+            throw ( (new Error(`Profile ${profile.name} does not exist`)));
+        }
+        if (profile.isDefault) {
+            throw ( (new Error(localizeWithPath(_moduleId, 3, "Cannot delete the default profile"))));
+        }
+        await this.userDataProfilesService.removeProfile(profile);
+        this.telemetryService.publicLog2('profileManagementActionExecuted', { id: 'removeProfile' });
+    }
+    async switchProfile(profile) {
+        const workspaceIdentifier = toWorkspaceIdentifier(this.workspaceContextService.getWorkspace());
+        if (!( (this.userDataProfilesService.profiles.some(p => p.id === profile.id)))) {
+            throw ( (new Error(`Profile ${profile.name} does not exist`)));
+        }
+        if (this.userDataProfileService.currentProfile.id === profile.id) {
+            return;
+        }
+        await this.userDataProfilesService.setProfileForWorkspace(workspaceIdentifier, profile);
+        await this.changeCurrentProfile(profile);
+        this.telemetryService.publicLog2('profileManagementActionExecuted', { id: 'switchProfile' });
+    }
+    async getBuiltinProfileTemplates() {
+        if (this.productService.profileTemplatesUrl) {
+            try {
+                const context = await this.requestService.request({ type: 'GET', url: this.productService.profileTemplatesUrl }, CancellationToken.None);
+                if (context.res.statusCode === 200) {
+                    return (await asJson(context)) || [];
+                }
+                else {
+                    this.logService.error('Could not get profile templates.', context.res.statusCode);
+                }
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return [];
+    }
+    async changeCurrentProfile(profile, reloadMessage) {
+        const isRemoteWindow = !!this.environmentService.remoteAuthority;
+        const shouldRestartExtensionHosts = this.userDataProfileService.currentProfile.id !== profile.id || !equals(this.userDataProfileService.currentProfile.useDefaultFlags, profile.useDefaultFlags);
+        if (shouldRestartExtensionHosts) {
+            if (!isRemoteWindow) {
+                if (!(await this.extensionService.stopExtensionHosts(( localizeWithPath(_moduleId, 4, "Switching to a profile."))))) {
+                    if (( (this.userDataProfilesService.profiles.some(p => p.id === this.userDataProfileService.currentProfile.id)))) {
+                        await this.userDataProfilesService.setProfileForWorkspace(toWorkspaceIdentifier(this.workspaceContextService.getWorkspace()), this.userDataProfileService.currentProfile);
+                    }
+                    throw ( (new CancellationError()));
+                }
+            }
+        }
+        await this.userDataProfileService.updateCurrentProfile(profile);
+        if (shouldRestartExtensionHosts) {
+            if (isRemoteWindow) {
+                const { confirmed } = await this.dialogService.confirm({
+                    message: reloadMessage ?? ( localizeWithPath(_moduleId, 5, "Switching a profile requires reloading VS Code.")),
+                    primaryButton: ( localizeWithPath(_moduleId, 6, "&&Reload")),
+                });
+                if (confirmed) {
+                    await this.hostService.reload();
+                }
+            }
+            else {
+                await this.extensionService.startExtensionHosts();
+            }
+        }
+    }
+};
+UserDataProfileManagementService = ( (__decorate([
+    ( (__param(0, IUserDataProfilesService))),
+    ( (__param(1, IUserDataProfileService))),
+    ( (__param(2, IHostService))),
+    ( (__param(3, IDialogService))),
+    ( (__param(4, IWorkspaceContextService))),
+    ( (__param(5, IExtensionService))),
+    ( (__param(6, IWorkbenchEnvironmentService))),
+    ( (__param(7, ITelemetryService))),
+    ( (__param(8, IProductService))),
+    ( (__param(9, IRequestService))),
+    ( (__param(10, ILogService)))
+], UserDataProfileManagementService)));
+
+export { UserDataProfileManagementService };

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

@@ -0,0 +1,39 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { AbstractUserDataProfileStorageService } from '../../../../platform/userDataProfile/common/userDataProfileStorageService.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { isProfileUsingDefaultStorage } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IndexedDBStorageDatabase } from 'vscode/vscode/vs/workbench/services/storage/browser/storageService';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+
+let UserDataProfileStorageService = class UserDataProfileStorageService extends AbstractUserDataProfileStorageService {
+    constructor(storageService, userDataProfileService, logService) {
+        super(storageService);
+        this.userDataProfileService = userDataProfileService;
+        this.logService = logService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        const disposables = this._register(( new DisposableStore()));
+        this._register(Event.filter(storageService.onDidChangeTarget, e => e.scope === 0 , disposables)(() => this.onDidChangeStorageTargetInCurrentProfile()));
+        this._register(storageService.onDidChangeValue(0 , undefined, disposables)(e => this.onDidChangeStorageValueInCurrentProfile(e)));
+    }
+    onDidChangeStorageTargetInCurrentProfile() {
+        this._onDidChange.fire({ targetChanges: [this.userDataProfileService.currentProfile], valueChanges: [] });
+    }
+    onDidChangeStorageValueInCurrentProfile(e) {
+        this._onDidChange.fire({ targetChanges: [], valueChanges: [{ profile: this.userDataProfileService.currentProfile, changes: [e] }] });
+    }
+    createStorageDatabase(profile) {
+        return isProfileUsingDefaultStorage(profile) ? IndexedDBStorageDatabase.createApplicationStorage(this.logService) : IndexedDBStorageDatabase.createProfileStorage(profile, this.logService);
+    }
+};
+UserDataProfileStorageService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, ILogService))
+], UserDataProfileStorageService));
+
+export { UserDataProfileStorageService };