@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/platform/userDataSync/common/userDataSyncService.js

@@ -1,781 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { equals } from '../../../base/common/arrays.js';
-import { createCancelablePromise } from '../../../base/common/async.js';
-import { CancellationTokenSource } from '../../../base/common/cancellation.js';
-import { toErrorMessage } from '../../../base/common/errorMessage.js';
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { isEqual } from '../../../base/common/resources.js';
-import { isBoolean, isUndefined } from '../../../base/common/types.js';
-import { generateUuid } from '../../../base/common/uuid.js';
-import { IConfigurationService } from '../../configuration/common/configuration.js';
-import { IExtensionGalleryService } from '../../extensionManagement/common/extensionManagement.js';
-import { IFileService } from '../../files/common/files.js';
-import { IInstantiationService } from '../../instantiation/common/instantiation.js';
-import { IStorageService } from '../../storage/common/storage.js';
-import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.js';
-import { ExtensionsSynchroniser } from '../../../../../../override/vs/platform/userDataSync/common/extensionsSync.js';
-import { GlobalStateSynchroniser } from '../../../../../../override/vs/platform/userDataSync/common/globalStateSync.js';
-import { KeybindingsSynchroniser } from './keybindingsSync.js';
-import { SettingsSynchroniser } from './settingsSync.js';
-import { SnippetsSynchroniser } from './snippetsSync.js';
-import { TasksSynchroniser } from './tasksSync.js';
-import { UserDataProfilesManifestSynchroniser } from './userDataProfilesManifestSync.js';
-import { createSyncHeaders, UserDataSyncError, IUserDataSyncStoreService, IUserDataSyncStoreManagementService, IUserDataSyncLogService, IUserDataSyncEnablementService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, ALL_SYNC_RESOURCES, USER_DATA_SYNC_CONFIGURATION_SCOPE, UserDataSyncStoreError } from './userDataSync.js';
-const LAST_SYNC_TIME_KEY = 'sync.lastSyncTime';
-let UserDataSyncService = class UserDataSyncService extends Disposable {
-    get status() { return this._status; }
-    get conflicts() { return this._conflicts; }
-    get lastSyncTime() { return this._lastSyncTime; }
-    constructor(fileService, userDataSyncStoreService, userDataSyncStoreManagementService, instantiationService, logService, telemetryService, storageService, userDataSyncEnablementService, userDataProfilesService, userDataSyncResourceProviderService, userDataSyncLocalStoreService) {
-        super();
-        this.fileService = fileService;
-        this.userDataSyncStoreService = userDataSyncStoreService;
-        this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
-        this.instantiationService = instantiationService;
-        this.logService = logService;
-        this.telemetryService = telemetryService;
-        this.storageService = storageService;
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.userDataSyncResourceProviderService = userDataSyncResourceProviderService;
-        this.userDataSyncLocalStoreService = userDataSyncLocalStoreService;
-        this._status = "uninitialized" ;
-        this._onDidChangeStatus = this._register(( new Emitter()));
-        this.onDidChangeStatus = this._onDidChangeStatus.event;
-        this._onDidChangeLocal = this._register(( new Emitter()));
-        this.onDidChangeLocal = this._onDidChangeLocal.event;
-        this._conflicts = [];
-        this._onDidChangeConflicts = this._register(( new Emitter()));
-        this.onDidChangeConflicts = this._onDidChangeConflicts.event;
-        this._syncErrors = [];
-        this._onSyncErrors = this._register(( new Emitter()));
-        this.onSyncErrors = this._onSyncErrors.event;
-        this._lastSyncTime = undefined;
-        this._onDidChangeLastSyncTime = this._register(( new Emitter()));
-        this.onDidChangeLastSyncTime = this._onDidChangeLastSyncTime.event;
-        this._onDidResetLocal = this._register(( new Emitter()));
-        this.onDidResetLocal = this._onDidResetLocal.event;
-        this._onDidResetRemote = this._register(( new Emitter()));
-        this.onDidResetRemote = this._onDidResetRemote.event;
-        this.activeProfileSynchronizers = ( new Map());
-        this._status = userDataSyncStoreManagementService.userDataSyncStore ? "idle"  : "uninitialized" ;
-        this._lastSyncTime = this.storageService.getNumber(LAST_SYNC_TIME_KEY, -1 , undefined);
-        this._register(toDisposable(() => this.clearActiveProfileSynchronizers()));
-    }
-    async createSyncTask(manifest, disableCache) {
-        this.checkEnablement();
-        this.logService.info('Sync started.');
-        const startTime = ( new Date()).getTime();
-        const executionId = generateUuid();
-        try {
-            const syncHeaders = createSyncHeaders(executionId);
-            if (disableCache) {
-                syncHeaders['Cache-Control'] = 'no-cache';
-            }
-            manifest = await this.userDataSyncStoreService.manifest(manifest, syncHeaders);
-        }
-        catch (error) {
-            const userDataSyncError = UserDataSyncError.toUserDataSyncError(error);
-            reportUserDataSyncError(userDataSyncError, executionId, this.userDataSyncStoreManagementService, this.telemetryService);
-            throw userDataSyncError;
-        }
-        const that = this;
-        let cancellablePromise;
-        return {
-            manifest,
-            async run() {
-                cancellablePromise = createCancelablePromise(token => that.sync(manifest, false, executionId, token));
-                await cancellablePromise.finally(() => cancellablePromise = undefined);
-                that.logService.info(`Sync done. Took ${( new Date()).getTime() - startTime}ms`);
-                that.updateLastSyncTime();
-            },
-            stop() {
-                cancellablePromise?.cancel();
-                return that.stop();
-            }
-        };
-    }
-    async createManualSyncTask() {
-        this.checkEnablement();
-        if (this.userDataSyncEnablementService.isEnabled()) {
-            throw new UserDataSyncError('Cannot start manual sync when sync is enabled', "LocalError" );
-        }
-        this.logService.info('Sync started.');
-        const startTime = ( new Date()).getTime();
-        const executionId = generateUuid();
-        const syncHeaders = createSyncHeaders(executionId);
-        let manifest;
-        try {
-            manifest = await this.userDataSyncStoreService.manifest(null, syncHeaders);
-        }
-        catch (error) {
-            const userDataSyncError = UserDataSyncError.toUserDataSyncError(error);
-            reportUserDataSyncError(userDataSyncError, executionId, this.userDataSyncStoreManagementService, this.telemetryService);
-            throw userDataSyncError;
-        }
-        await this.resetLocal();
-        const that = this;
-        const cancellableToken = ( new CancellationTokenSource());
-        return {
-            id: executionId,
-            async merge() {
-                return that.sync(manifest, true, executionId, cancellableToken.token);
-            },
-            async apply() {
-                try {
-                    try {
-                        await that.applyManualSync(manifest, executionId, cancellableToken.token);
-                    }
-                    catch (error) {
-                        if (UserDataSyncError.toUserDataSyncError(error).code === "MethodNotFound" ) {
-                            that.logService.info('Client is making invalid requests. Cleaning up data...');
-                            await that.cleanUpRemoteData();
-                            that.logService.info('Applying manual sync again...');
-                            await that.applyManualSync(manifest, executionId, cancellableToken.token);
-                        }
-                        else {
-                            throw error;
-                        }
-                    }
-                }
-                catch (error) {
-                    that.logService.error(error);
-                    throw error;
-                }
-                that.logService.info(`Sync done. Took ${( new Date()).getTime() - startTime}ms`);
-                that.updateLastSyncTime();
-            },
-            async stop() {
-                cancellableToken.cancel();
-                await that.stop();
-                await that.resetLocal();
-            }
-        };
-    }
-    async sync(manifest, merge, executionId, token) {
-        this._syncErrors = [];
-        try {
-            if (this.status !== "hasConflicts" ) {
-                this.setStatus("syncing" );
-            }
-            const defaultProfileSynchronizer = this.getOrCreateActiveProfileSynchronizer(this.userDataProfilesService.defaultProfile, undefined);
-            this._syncErrors.push(...(await this.syncProfile(defaultProfileSynchronizer, manifest, merge, executionId, token)));
-            const userDataProfileManifestSynchronizer = defaultProfileSynchronizer.enabled.find(s => s.resource === "profiles" );
-            if (userDataProfileManifestSynchronizer) {
-                const syncProfiles = (await userDataProfileManifestSynchronizer.getLastSyncedProfiles()) || [];
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                await this.syncRemoteProfiles(syncProfiles, manifest, merge, executionId, token);
-            }
-        }
-        finally {
-            if (this.status !== "hasConflicts" ) {
-                this.setStatus("idle" );
-            }
-            this._onSyncErrors.fire(this._syncErrors);
-        }
-    }
-    async syncRemoteProfiles(remoteProfiles, manifest, merge, executionId, token) {
-        for (const syncProfile of remoteProfiles) {
-            if (token.isCancellationRequested) {
-                return;
-            }
-            const profile = this.userDataProfilesService.profiles.find(p => p.id === syncProfile.id);
-            if (!profile) {
-                this.logService.error(`Profile with id:${syncProfile.id} and name: ${syncProfile.name} does not exist locally to sync.`);
-                continue;
-            }
-            this.logService.info('Syncing profile.', syncProfile.name);
-            const profileSynchronizer = this.getOrCreateActiveProfileSynchronizer(profile, syncProfile);
-            this._syncErrors.push(...(await this.syncProfile(profileSynchronizer, manifest, merge, executionId, token)));
-        }
-        for (const [key, profileSynchronizerItem] of this.activeProfileSynchronizers.entries()) {
-            if (( this.userDataProfilesService.profiles.some(p => p.id === profileSynchronizerItem[0].profile.id))) {
-                continue;
-            }
-            profileSynchronizerItem[1].dispose();
-            this.activeProfileSynchronizers.delete(key);
-        }
-    }
-    async applyManualSync(manifest, executionId, token) {
-        const profileSynchronizers = this.getActiveProfileSynchronizers();
-        for (const profileSynchronizer of profileSynchronizers) {
-            if (token.isCancellationRequested) {
-                return;
-            }
-            await profileSynchronizer.apply(executionId, token);
-        }
-        const defaultProfileSynchronizer = profileSynchronizers.find(s => s.profile.isDefault);
-        if (!defaultProfileSynchronizer) {
-            return;
-        }
-        const userDataProfileManifestSynchronizer = defaultProfileSynchronizer.enabled.find(s => s.resource === "profiles" );
-        if (!userDataProfileManifestSynchronizer) {
-            return;
-        }
-        const remoteProfiles = (await userDataProfileManifestSynchronizer.getRemoteSyncedProfiles(manifest?.latest ?? null)) || [];
-        const remoteProfilesToSync = remoteProfiles.filter(remoteProfile => profileSynchronizers.every(s => s.profile.id !== remoteProfile.id));
-        if (remoteProfilesToSync.length) {
-            await this.syncRemoteProfiles(remoteProfilesToSync, manifest, false, executionId, token);
-        }
-    }
-    async syncProfile(profileSynchronizer, manifest, merge, executionId, token) {
-        const errors = await profileSynchronizer.sync(manifest, merge, executionId, token);
-        return ( errors.map(
-            ([syncResource, error]) => ({ profile: profileSynchronizer.profile, syncResource, error })
-        ));
-    }
-    async stop() {
-        if (this.status !== "idle" ) {
-            await Promise.allSettled(( this.getActiveProfileSynchronizers().map(profileSynchronizer => profileSynchronizer.stop())));
-        }
-    }
-    async resolveContent(resource) {
-        const content = await this.userDataSyncResourceProviderService.resolveContent(resource);
-        if (content) {
-            return content;
-        }
-        for (const profileSynchronizer of this.getActiveProfileSynchronizers()) {
-            for (const synchronizer of profileSynchronizer.enabled) {
-                const content = await synchronizer.resolveContent(resource);
-                if (content) {
-                    return content;
-                }
-            }
-        }
-        return null;
-    }
-    async replace(syncResourceHandle) {
-        this.checkEnablement();
-        const profileSyncResource = this.userDataSyncResourceProviderService.resolveUserDataSyncResource(syncResourceHandle);
-        if (!profileSyncResource) {
-            return;
-        }
-        const content = await this.resolveContent(syncResourceHandle.uri);
-        if (!content) {
-            return;
-        }
-        await this.performAction(profileSyncResource.profile, async (synchronizer) => {
-            if (profileSyncResource.syncResource === synchronizer.resource) {
-                await synchronizer.replace(content);
-                return true;
-            }
-            return undefined;
-        });
-        return;
-    }
-    async accept(syncResource, resource, content, apply) {
-        this.checkEnablement();
-        await this.performAction(syncResource.profile, async (synchronizer) => {
-            if (syncResource.syncResource === synchronizer.resource) {
-                await synchronizer.accept(resource, content);
-                if (apply) {
-                    await synchronizer.apply(isBoolean(apply) ? false : apply.force, createSyncHeaders(generateUuid()));
-                }
-                return true;
-            }
-            return undefined;
-        });
-    }
-    async hasLocalData() {
-        const result = await this.performAction(this.userDataProfilesService.defaultProfile, async (synchronizer) => {
-            if (synchronizer.resource !== "globalState"  && (await synchronizer.hasLocalData())) {
-                return true;
-            }
-            return undefined;
-        });
-        return !!result;
-    }
-    async hasPreviouslySynced() {
-        const result = await this.performAction(this.userDataProfilesService.defaultProfile, async (synchronizer) => {
-            if (await synchronizer.hasPreviouslySynced()) {
-                return true;
-            }
-            return undefined;
-        });
-        return !!result;
-    }
-    async reset() {
-        this.checkEnablement();
-        await this.resetRemote();
-        await this.resetLocal();
-    }
-    async resetRemote() {
-        this.checkEnablement();
-        try {
-            await this.userDataSyncStoreService.clear();
-            this.logService.info('Cleared data on server');
-        }
-        catch (e) {
-            this.logService.error(e);
-        }
-        this._onDidResetRemote.fire();
-    }
-    async resetLocal() {
-        this.checkEnablement();
-        this._lastSyncTime = undefined;
-        this.storageService.remove(LAST_SYNC_TIME_KEY, -1 );
-        for (const [synchronizer] of ( this.activeProfileSynchronizers.values())) {
-            try {
-                await synchronizer.resetLocal();
-            }
-            catch (e) {
-                this.logService.error(e);
-            }
-        }
-        this.clearActiveProfileSynchronizers();
-        this._onDidResetLocal.fire();
-        this.logService.info('Did reset the local sync state.');
-    }
-    async cleanUpRemoteData() {
-        const remoteProfiles = await this.userDataSyncResourceProviderService.getRemoteSyncedProfiles();
-        const remoteProfileCollections = ( remoteProfiles.map(profile => profile.collection));
-        const allCollections = await this.userDataSyncStoreService.getAllCollections();
-        const redundantCollections = allCollections.filter(c => !remoteProfileCollections.includes(c));
-        if (redundantCollections.length) {
-            this.logService.info(`Deleting ${redundantCollections.length} redundant collections on server`);
-            await Promise.allSettled(( redundantCollections.map(
-                collectionId => this.userDataSyncStoreService.deleteCollection(collectionId)
-            )));
-            this.logService.info(`Deleted redundant collections on server`);
-        }
-        const updatedRemoteProfiles = remoteProfiles.filter(profile => allCollections.includes(profile.collection));
-        if (updatedRemoteProfiles.length !== remoteProfiles.length) {
-            const profileManifestSynchronizer = this.instantiationService.createInstance(UserDataProfilesManifestSynchroniser, this.userDataProfilesService.defaultProfile, undefined);
-            try {
-                this.logService.info('Resetting the last synced state of profiles');
-                await profileManifestSynchronizer.resetLocal();
-                this.logService.info('Did reset the last synced state of profiles');
-                this.logService.info(`Updating remote profiles with invalid collections on server`);
-                await profileManifestSynchronizer.updateRemoteProfiles(updatedRemoteProfiles, null);
-                this.logService.info(`Updated remote profiles on server`);
-            }
-            finally {
-                profileManifestSynchronizer.dispose();
-            }
-        }
-    }
-    async saveRemoteActivityData(location) {
-        this.checkEnablement();
-        const data = await this.userDataSyncStoreService.getActivityData();
-        await this.fileService.writeFile(location, data);
-    }
-    async extractActivityData(activityDataResource, location) {
-        const content = ( (await this.fileService.readFile(activityDataResource)).value.toString());
-        const activityData = JSON.parse(content);
-        if (activityData.resources) {
-            for (const resource in activityData.resources) {
-                for (const version of activityData.resources[resource]) {
-                    await this.userDataSyncLocalStoreService.writeResource(resource, version.content, ( new Date(version.created * 1000)), undefined, location);
-                }
-            }
-        }
-        if (activityData.collections) {
-            for (const collection in activityData.collections) {
-                for (const resource in activityData.collections[collection].resources) {
-                    for (const version of activityData.collections[collection].resources?.[resource] ?? []) {
-                        await this.userDataSyncLocalStoreService.writeResource(resource, version.content, ( new Date(version.created * 1000)), collection, location);
-                    }
-                }
-            }
-        }
-    }
-    async performAction(profile, action) {
-        const disposables = ( new DisposableStore());
-        try {
-            const activeProfileSyncronizer = this.activeProfileSynchronizers.get(profile.id);
-            if (activeProfileSyncronizer) {
-                const result = await this.performActionWithProfileSynchronizer(activeProfileSyncronizer[0], action, disposables);
-                return isUndefined(result) ? null : result;
-            }
-            if (profile.isDefault) {
-                const defaultProfileSynchronizer = disposables.add(this.instantiationService.createInstance(ProfileSynchronizer, profile, undefined));
-                const result = await this.performActionWithProfileSynchronizer(defaultProfileSynchronizer, action, disposables);
-                return isUndefined(result) ? null : result;
-            }
-            if (this.userDataProfilesService.isEnabled()) {
-                return null;
-            }
-            const userDataProfileManifestSynchronizer = disposables.add(this.instantiationService.createInstance(UserDataProfilesManifestSynchroniser, profile, undefined));
-            const manifest = await this.userDataSyncStoreService.manifest(null);
-            const syncProfiles = (await userDataProfileManifestSynchronizer.getRemoteSyncedProfiles(manifest?.latest ?? null)) || [];
-            const syncProfile = syncProfiles.find(syncProfile => syncProfile.id === profile.id);
-            if (syncProfile) {
-                const profileSynchronizer = disposables.add(this.instantiationService.createInstance(ProfileSynchronizer, profile, syncProfile.collection));
-                const result = await this.performActionWithProfileSynchronizer(profileSynchronizer, action, disposables);
-                return isUndefined(result) ? null : result;
-            }
-            return null;
-        }
-        finally {
-            disposables.dispose();
-        }
-    }
-    async performActionWithProfileSynchronizer(profileSynchronizer, action, disposables) {
-        const allSynchronizers = [...profileSynchronizer.enabled, ...profileSynchronizer.disabled.reduce((synchronizers, syncResource) => {
-                if (syncResource !== "workspaceState" ) {
-                    synchronizers.push(disposables.add(profileSynchronizer.createSynchronizer(syncResource)));
-                }
-                return synchronizers;
-            }, [])];
-        for (const synchronizer of allSynchronizers) {
-            const result = await action(synchronizer);
-            if (!isUndefined(result)) {
-                return result;
-            }
-        }
-        return undefined;
-    }
-    setStatus(status) {
-        const oldStatus = this._status;
-        if (this._status !== status) {
-            this._status = status;
-            this._onDidChangeStatus.fire(status);
-            if (oldStatus === "hasConflicts" ) {
-                this.updateLastSyncTime();
-            }
-        }
-    }
-    updateConflicts() {
-        const conflicts = ( this.getActiveProfileSynchronizers().map(synchronizer => synchronizer.conflicts)).flat();
-        if (!equals(this._conflicts, conflicts, (a, b) => a.profile.id === b.profile.id && a.syncResource === b.syncResource && equals(a.conflicts, b.conflicts, (a, b) => isEqual(a.previewResource, b.previewResource)))) {
-            this._conflicts = conflicts;
-            this._onDidChangeConflicts.fire(conflicts);
-        }
-    }
-    updateLastSyncTime() {
-        if (this.status === "idle" ) {
-            this._lastSyncTime = ( new Date()).getTime();
-            this.storageService.store(LAST_SYNC_TIME_KEY, this._lastSyncTime, -1 , 1 );
-            this._onDidChangeLastSyncTime.fire(this._lastSyncTime);
-        }
-    }
-    getOrCreateActiveProfileSynchronizer(profile, syncProfile) {
-        let activeProfileSynchronizer = this.activeProfileSynchronizers.get(profile.id);
-        if (activeProfileSynchronizer && activeProfileSynchronizer[0].collection !== syncProfile?.collection) {
-            this.logService.error('Profile synchronizer collection does not match with the remote sync profile collection');
-            activeProfileSynchronizer[1].dispose();
-            activeProfileSynchronizer = undefined;
-            this.activeProfileSynchronizers.delete(profile.id);
-        }
-        if (!activeProfileSynchronizer) {
-            const disposables = ( new DisposableStore());
-            const profileSynchronizer = disposables.add(this.instantiationService.createInstance(ProfileSynchronizer, profile, syncProfile?.collection));
-            disposables.add(profileSynchronizer.onDidChangeStatus(e => this.setStatus(e)));
-            disposables.add(profileSynchronizer.onDidChangeConflicts(conflicts => this.updateConflicts()));
-            disposables.add(profileSynchronizer.onDidChangeLocal(e => this._onDidChangeLocal.fire(e)));
-            this.activeProfileSynchronizers.set(profile.id, activeProfileSynchronizer = [profileSynchronizer, disposables]);
-        }
-        return activeProfileSynchronizer[0];
-    }
-    getActiveProfileSynchronizers() {
-        const profileSynchronizers = [];
-        for (const [profileSynchronizer] of ( this.activeProfileSynchronizers.values())) {
-            profileSynchronizers.push(profileSynchronizer);
-        }
-        return profileSynchronizers;
-    }
-    clearActiveProfileSynchronizers() {
-        this.activeProfileSynchronizers.forEach(([, disposable]) => disposable.dispose());
-        this.activeProfileSynchronizers.clear();
-    }
-    checkEnablement() {
-        if (!this.userDataSyncStoreManagementService.userDataSyncStore) {
-            throw new Error('Not enabled');
-        }
-    }
-};
-UserDataSyncService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUserDataSyncStoreService)),
-    ( __param(2, IUserDataSyncStoreManagementService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IUserDataSyncLogService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IUserDataSyncEnablementService)),
-    ( __param(8, IUserDataProfilesService)),
-    ( __param(9, IUserDataSyncResourceProviderService)),
-    ( __param(10, IUserDataSyncLocalStoreService))
-], UserDataSyncService));
-let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
-    get enabled() { return ( this._enabled.sort((a, b) => a[1] - b[1]).map(([synchronizer]) => synchronizer)); }
-    get disabled() { return ALL_SYNC_RESOURCES.filter(syncResource => !this.userDataSyncEnablementService.isResourceEnabled(syncResource)); }
-    get status() { return this._status; }
-    get conflicts() { return this._conflicts; }
-    constructor(profile, collection, userDataSyncEnablementService, instantiationService, extensionGalleryService, userDataSyncStoreManagementService, telemetryService, logService, userDataProfilesService, configurationService) {
-        super();
-        this.profile = profile;
-        this.collection = collection;
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this.instantiationService = instantiationService;
-        this.extensionGalleryService = extensionGalleryService;
-        this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
-        this.telemetryService = telemetryService;
-        this.logService = logService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.configurationService = configurationService;
-        this._enabled = [];
-        this._status = "idle" ;
-        this._onDidChangeStatus = this._register(( new Emitter()));
-        this.onDidChangeStatus = this._onDidChangeStatus.event;
-        this._onDidChangeLocal = this._register(( new Emitter()));
-        this.onDidChangeLocal = this._onDidChangeLocal.event;
-        this._conflicts = [];
-        this._onDidChangeConflicts = this._register(( new Emitter()));
-        this.onDidChangeConflicts = this._onDidChangeConflicts.event;
-        this._register(userDataSyncEnablementService.onDidChangeResourceEnablement(([syncResource, enablement]) => this.onDidChangeResourceEnablement(syncResource, enablement)));
-        this._register(toDisposable(() => this._enabled.splice(0, this._enabled.length).forEach(([, , disposable]) => disposable.dispose())));
-        for (const syncResource of ALL_SYNC_RESOURCES) {
-            if (userDataSyncEnablementService.isResourceEnabled(syncResource)) {
-                this.registerSynchronizer(syncResource);
-            }
-        }
-    }
-    onDidChangeResourceEnablement(syncResource, enabled) {
-        if (enabled) {
-            this.registerSynchronizer(syncResource);
-        }
-        else {
-            this.deRegisterSynchronizer(syncResource);
-        }
-    }
-    registerSynchronizer(syncResource) {
-        if (( this._enabled.some(([synchronizer]) => synchronizer.resource === syncResource))) {
-            return;
-        }
-        if (syncResource === "extensions"  && !this.extensionGalleryService.isEnabled()) {
-            this.logService.info('Skipping extensions sync because gallery is not configured');
-            return;
-        }
-        if (syncResource === "profiles" ) {
-            if (!this.profile.isDefault) {
-                return;
-            }
-            if (!this.userDataProfilesService.isEnabled()) {
-                return;
-            }
-        }
-        if (syncResource === "workspaceState" ) {
-            return;
-        }
-        if (syncResource !== "profiles"  && this.profile.useDefaultFlags?.[syncResource]) {
-            this.logService.debug(`Skipping syncing ${syncResource} in ${this.profile.name} because it is already synced by default profile`);
-            return;
-        }
-        const disposables = ( new DisposableStore());
-        const synchronizer = disposables.add(this.createSynchronizer(syncResource));
-        disposables.add(synchronizer.onDidChangeStatus(() => this.updateStatus()));
-        disposables.add(synchronizer.onDidChangeConflicts(() => this.updateConflicts()));
-        disposables.add(synchronizer.onDidChangeLocal(() => this._onDidChangeLocal.fire(syncResource)));
-        const order = this.getOrder(syncResource);
-        this._enabled.push([synchronizer, order, disposables]);
-    }
-    deRegisterSynchronizer(syncResource) {
-        const index = this._enabled.findIndex(([synchronizer]) => synchronizer.resource === syncResource);
-        if (index !== -1) {
-            const [[synchronizer, , disposable]] = this._enabled.splice(index, 1);
-            disposable.dispose();
-            this.updateStatus();
-            Promise.allSettled([synchronizer.stop(), synchronizer.resetLocal()])
-                .then(null, error => this.logService.error(error));
-        }
-    }
-    createSynchronizer(syncResource) {
-        switch (syncResource) {
-            case "settings" : return this.instantiationService.createInstance(SettingsSynchroniser, this.profile, this.collection);
-            case "keybindings" : return this.instantiationService.createInstance(KeybindingsSynchroniser, this.profile, this.collection);
-            case "snippets" : return this.instantiationService.createInstance(SnippetsSynchroniser, this.profile, this.collection);
-            case "tasks" : return this.instantiationService.createInstance(TasksSynchroniser, this.profile, this.collection);
-            case "globalState" : return this.instantiationService.createInstance(GlobalStateSynchroniser, this.profile, this.collection);
-            case "extensions" : return this.instantiationService.createInstance(ExtensionsSynchroniser, this.profile, this.collection);
-            case "profiles" : return this.instantiationService.createInstance(UserDataProfilesManifestSynchroniser, this.profile, this.collection);
-        }
-    }
-    async sync(manifest, merge, executionId, token) {
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const synchronizers = this.enabled;
-        if (!synchronizers.length) {
-            return [];
-        }
-        try {
-            const syncErrors = [];
-            const syncHeaders = createSyncHeaders(executionId);
-            const resourceManifest = (this.collection ? manifest?.collections?.[this.collection]?.latest : manifest?.latest) ?? null;
-            const userDataSyncConfiguration = merge ? await this.getUserDataSyncConfiguration(resourceManifest) : {};
-            for (const synchroniser of synchronizers) {
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                if (!this.userDataSyncEnablementService.isResourceEnabled(synchroniser.resource)) {
-                    return [];
-                }
-                try {
-                    if (merge) {
-                        const preview = await synchroniser.preview(resourceManifest, userDataSyncConfiguration, syncHeaders);
-                        if (preview) {
-                            for (const resourcePreview of preview.resourcePreviews) {
-                                if (((resourcePreview.localChange !== 0  || resourcePreview.remoteChange !== 0) ) && resourcePreview.mergeState === "preview" ) {
-                                    await synchroniser.merge(resourcePreview.previewResource);
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        await synchroniser.sync(resourceManifest, syncHeaders);
-                    }
-                }
-                catch (e) {
-                    const userDataSyncError = UserDataSyncError.toUserDataSyncError(e);
-                    reportUserDataSyncError(userDataSyncError, executionId, this.userDataSyncStoreManagementService, this.telemetryService);
-                    if (canBailout(e)) {
-                        throw userDataSyncError;
-                    }
-                    this.logService.error(e);
-                    this.logService.error(`${synchroniser.resource}: ${toErrorMessage(e)}`);
-                    syncErrors.push([synchroniser.resource, userDataSyncError]);
-                }
-            }
-            return syncErrors;
-        }
-        finally {
-            this.updateStatus();
-        }
-    }
-    async apply(executionId, token) {
-        const syncHeaders = createSyncHeaders(executionId);
-        for (const synchroniser of this.enabled) {
-            if (token.isCancellationRequested) {
-                return;
-            }
-            try {
-                await synchroniser.apply(false, syncHeaders);
-            }
-            catch (e) {
-                const userDataSyncError = UserDataSyncError.toUserDataSyncError(e);
-                reportUserDataSyncError(userDataSyncError, executionId, this.userDataSyncStoreManagementService, this.telemetryService);
-                if (canBailout(e)) {
-                    throw userDataSyncError;
-                }
-                this.logService.error(e);
-                this.logService.error(`${synchroniser.resource}: ${toErrorMessage(e)}`);
-            }
-        }
-    }
-    async stop() {
-        for (const synchroniser of this.enabled) {
-            try {
-                if (synchroniser.status !== "idle" ) {
-                    await synchroniser.stop();
-                }
-            }
-            catch (e) {
-                this.logService.error(e);
-            }
-        }
-    }
-    async resetLocal() {
-        for (const synchroniser of this.enabled) {
-            try {
-                await synchroniser.resetLocal();
-            }
-            catch (e) {
-                this.logService.error(`${synchroniser.resource}: ${toErrorMessage(e)}`);
-                this.logService.error(e);
-            }
-        }
-    }
-    async getUserDataSyncConfiguration(manifest) {
-        if (!this.profile.isDefault) {
-            return {};
-        }
-        const local = this.configurationService.getValue(USER_DATA_SYNC_CONFIGURATION_SCOPE);
-        const settingsSynchronizer = this.enabled.find(synchronizer => synchronizer instanceof SettingsSynchroniser);
-        if (settingsSynchronizer) {
-            const remote = await settingsSynchronizer.getRemoteUserDataSyncConfiguration(manifest);
-            return { ...local, ...remote };
-        }
-        return local;
-    }
-    setStatus(status) {
-        if (this._status !== status) {
-            this._status = status;
-            this._onDidChangeStatus.fire(status);
-        }
-    }
-    updateStatus() {
-        this.updateConflicts();
-        if (( this.enabled.some(s => s.status === "hasConflicts" ))) {
-            return this.setStatus("hasConflicts" );
-        }
-        if (( this.enabled.some(s => s.status === "syncing" ))) {
-            return this.setStatus("syncing" );
-        }
-        return this.setStatus("idle" );
-    }
-    updateConflicts() {
-        const conflicts = ( this.enabled.filter(s => s.status === "hasConflicts" )
-            .filter(s => s.conflicts.conflicts.length > 0)
-            .map(s => s.conflicts));
-        if (!equals(this._conflicts, conflicts, (a, b) => a.syncResource === b.syncResource && equals(a.conflicts, b.conflicts, (a, b) => isEqual(a.previewResource, b.previewResource)))) {
-            this._conflicts = conflicts;
-            this._onDidChangeConflicts.fire(conflicts);
-        }
-    }
-    getOrder(syncResource) {
-        switch (syncResource) {
-            case "settings" : return 0;
-            case "keybindings" : return 1;
-            case "snippets" : return 2;
-            case "tasks" : return 3;
-            case "globalState" : return 4;
-            case "extensions" : return 5;
-            case "profiles" : return 6;
-            case "workspaceState" : return 7;
-        }
-    }
-};
-ProfileSynchronizer = ( __decorate([
-    ( __param(2, IUserDataSyncEnablementService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IExtensionGalleryService)),
-    ( __param(5, IUserDataSyncStoreManagementService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IUserDataSyncLogService)),
-    ( __param(8, IUserDataProfilesService)),
-    ( __param(9, IConfigurationService))
-], ProfileSynchronizer));
-function canBailout(e) {
-    if (e instanceof UserDataSyncError) {
-        switch (e.code) {
-            case "MethodNotFound" :
-            case "TooLarge" :
-            case "RemoteTooManyRequests" :
-            case "TooManyRequestsAndRetryAfter" :
-            case "LocalTooManyRequests" :
-            case "LocalTooManyProfiles" :
-            case "Gone" :
-            case "UpgradeRequired" :
-            case "IncompatibleRemoteContent" :
-            case "IncompatibleLocalContent" :
-                return true;
-        }
-    }
-    return false;
-}
-function reportUserDataSyncError(userDataSyncError, executionId, userDataSyncStoreManagementService, telemetryService) {
-    telemetryService.publicLog2('sync/error', {
-        code: userDataSyncError.code,
-        serverCode: userDataSyncError instanceof UserDataSyncStoreError ? String(userDataSyncError.serverCode) : undefined,
-        url: userDataSyncError instanceof UserDataSyncStoreError ? userDataSyncError.url : undefined,
-        resource: userDataSyncError.resource,
-        executionId,
-        service: ( userDataSyncStoreManagementService.userDataSyncStore.url.toString())
-    });
-}
-export { UserDataSyncService };