@codingame/monaco-vscode-user-data-sync-service-override 37.2.0 → 37.3.0

package/common.d.ts

@@ -0,0 +1,2 @@
+import type { IEditorOverrideServices } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/common.js

@@ -0,0 +1,36 @@
+
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IUserDataSyncLocalStoreService, IUserDataSyncResourceProviderService, IUserDataSyncLogService, IUserDataSyncService, IUserDataSyncEnablementService, IUserDataSyncStoreService, IUserDataSyncStoreManagementService, IUserDataAutoSyncService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { UserDataSyncAccountService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js';
+import { IUserDataSyncAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
+import { UserDataSyncMachinesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { IUserDataSyncMachinesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
+import { UserDataSyncStoreService, UserDataSyncStoreManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
+import { UserDataAutoSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataAutoSyncService.js';
+import { WebUserDataSyncEnablementService } from './vscode/src/vs/workbench/services/userDataSync/browser/webUserDataSyncEnablementService.js';
+import { UserDataSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncService.js';
+import { UserDataSyncLogService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLog.js';
+import { UserDataSyncResourceProviderService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncResourceProvider.js';
+import { UserDataSyncLocalStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLocalStoreService.js';
+import { UserDataSyncWorkbenchService } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js';
+import { IUserDataSyncWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
+import getServiceOverride$1 from '@codingame/monaco-vscode-user-data-profile-service-override';
+
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [IUserDataAutoSyncService.toString()]: new SyncDescriptor(UserDataAutoSyncService, [], true),
+        [IUserDataSyncStoreManagementService.toString()]: new SyncDescriptor(UserDataSyncStoreManagementService, [], true),
+        [IUserDataSyncStoreService.toString()]: new SyncDescriptor(UserDataSyncStoreService, [], true),
+        [IUserDataSyncEnablementService.toString()]: new SyncDescriptor(WebUserDataSyncEnablementService, [], true),
+        [IUserDataSyncService.toString()]: new SyncDescriptor(UserDataSyncService, [], true),
+        [IUserDataSyncLogService.toString()]: new SyncDescriptor(UserDataSyncLogService, [], true),
+        [IUserDataSyncAccountService.toString()]: new SyncDescriptor(UserDataSyncAccountService, [], true),
+        [IUserDataSyncMachinesService.toString()]: new SyncDescriptor(UserDataSyncMachinesService, [], true),
+        [IUserDataSyncResourceProviderService.toString()]: new SyncDescriptor(UserDataSyncResourceProviderService, [], true),
+        [IUserDataSyncLocalStoreService.toString()]: new SyncDescriptor(UserDataSyncLocalStoreService, [], true),
+        [IUserDataSyncWorkbenchService.toString()]: new SyncDescriptor(UserDataSyncWorkbenchService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/index.d.ts

@@ -1,2 +1 @@
-import type { IEditorOverrideServices } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices";
-export default function getServiceOverride(): IEditorOverrideServices;
+export { default } from "./common.js";

package/index.js

@@ -1,37 +1,3 @@
 
-import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
-import { IUserDataSyncLocalStoreService, IUserDataSyncResourceProviderService, IUserDataSyncLogService, IUserDataSyncService, IUserDataSyncEnablementService, IUserDataSyncStoreService, IUserDataSyncStoreManagementService, IUserDataAutoSyncService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
-import { UserDataSyncAccountService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js';
-import { IUserDataSyncAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
-import { UserDataSyncMachinesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
-import { IUserDataSyncMachinesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
-import { UserDataSyncStoreService, UserDataSyncStoreManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
-import { UserDataAutoSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataAutoSyncService.js';
-import { WebUserDataSyncEnablementService } from './vscode/src/vs/workbench/services/userDataSync/browser/webUserDataSyncEnablementService.js';
-import { UserDataSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncService.js';
-import { UserDataSyncLogService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLog.js';
-import { UserDataSyncResourceProviderService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncResourceProvider.js';
-import { UserDataSyncLocalStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLocalStoreService.js';
-import { UserDataSyncWorkbenchService } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js';
-import { IUserDataSyncWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
-import getServiceOverride$1 from '@codingame/monaco-vscode-user-data-profile-service-override';
+export { default } from './common.js';
 import './vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js';
-
-function getServiceOverride() {
-    return {
-        ...getServiceOverride$1(),
-        [IUserDataAutoSyncService.toString()]: new SyncDescriptor(UserDataAutoSyncService, [], true),
-        [IUserDataSyncStoreManagementService.toString()]: new SyncDescriptor(UserDataSyncStoreManagementService, [], true),
-        [IUserDataSyncStoreService.toString()]: new SyncDescriptor(UserDataSyncStoreService, [], true),
-        [IUserDataSyncEnablementService.toString()]: new SyncDescriptor(WebUserDataSyncEnablementService, [], true),
-        [IUserDataSyncService.toString()]: new SyncDescriptor(UserDataSyncService, [], true),
-        [IUserDataSyncLogService.toString()]: new SyncDescriptor(UserDataSyncLogService, [], true),
-        [IUserDataSyncAccountService.toString()]: new SyncDescriptor(UserDataSyncAccountService, [], true),
-        [IUserDataSyncMachinesService.toString()]: new SyncDescriptor(UserDataSyncMachinesService, [], true),
-        [IUserDataSyncResourceProviderService.toString()]: new SyncDescriptor(UserDataSyncResourceProviderService, [], true),
-        [IUserDataSyncLocalStoreService.toString()]: new SyncDescriptor(UserDataSyncLocalStoreService, [], true),
-        [IUserDataSyncWorkbenchService.toString()]: new SyncDescriptor(UserDataSyncWorkbenchService, [], true)
-    };
-}
-
-export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-user-data-sync-service-override",
-  "version": "37.2.0",
+  "version": "37.3.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - user-data-sync service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.2.0",
-    "@codingame/monaco-vscode-user-data-profile-service-override": "37.2.0"
+    "@codingame/monaco-vscode-api": "37.3.0",
+    "@codingame/monaco-vscode-user-data-profile-service-override": "37.3.0"
   },
   "main": "index.js",
   "module": "index.js",
@@ -32,6 +32,14 @@
       "types": "./vscode/src/*.d.ts",
       "default": "./vscode/src/*.js"
     },
+    "./session": {
+      "types": "./session.d.ts",
+      "default": "./session.js"
+    },
+    "./common": {
+      "types": "./common.d.ts",
+      "default": "./common.js"
+    },
     "./*": {
       "types": "./*.d.ts",
       "default": "./*.js"

package/session.d.ts

@@ -0,0 +1 @@
+export { default } from "./common.js";

package/session.js

@@ -0,0 +1,2 @@
+
+export { default } from './common.js';

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

@@ -129,10 +129,10 @@ let PromptsSynchronizer = class PromptsSynchronizer extends AbstractSynchroniser
         throw ( new Error(`Invalid Resource: ${( resource.toString())}`));
     }
     async applyResult(remoteUserData, lastSyncUserData, resourcePreviews, force) {
-        const accptedResourcePreviews = ( resourcePreviews.map(([resourcePreview, acceptResult]) => ({
+        const accptedResourcePreviews = resourcePreviews.map(([resourcePreview, acceptResult]) => ({
             ...resourcePreview,
             acceptResult
-        })));
+        }));
         if (accptedResourcePreviews.every((
             {
                 localChange,

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

@@ -479,24 +479,24 @@ class AutoSync extends Disposable {
         if (this.manifest === null && (await this.userDataSyncService.hasPreviouslySynced())) {
             if (this.hasSyncServiceChanged()) {
                 if (await this.hasDefaultServiceChanged()) {
-                    throw ( new UserDataAutoSyncError(( localize(2901, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2919, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 } else {
-                    throw ( new UserDataAutoSyncError(( localize(2902, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2920, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             } else {
-                throw ( new UserDataAutoSyncError(( localize(2903, "Cannot sync because syncing is turned off in the cloud")), UserDataSyncErrorCode.TurnedOff));
+                throw ( new UserDataAutoSyncError(( localize(2921, "Cannot sync because syncing is turned off in the cloud")), UserDataSyncErrorCode.TurnedOff));
             }
         }
         const sessionId = this.storageService.get(sessionIdKey, StorageScope.APPLICATION);
         if (sessionId && this.manifest && sessionId !== this.manifest.session) {
             if (this.hasSyncServiceChanged()) {
                 if (await this.hasDefaultServiceChanged()) {
-                    throw ( new UserDataAutoSyncError(( localize(2901, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2919, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 } else {
-                    throw ( new UserDataAutoSyncError(( localize(2902, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2920, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             } else {
-                throw ( new UserDataAutoSyncError(( localize(2904, "Cannot sync because current session is expired")), UserDataSyncErrorCode.SessionExpired));
+                throw ( new UserDataAutoSyncError(( localize(2922, "Cannot sync because current session is expired")), UserDataSyncErrorCode.SessionExpired));
             }
         }
         const machines = await this.userDataSyncMachinesService.getMachines(this.manifest || undefined);
@@ -506,7 +506,7 @@ class AutoSync extends Disposable {
         const currentMachine = machines.find(machine => machine.isCurrent);
         if (currentMachine?.disabled) {
             throw ( new UserDataAutoSyncError(( localize(
-                2905,
+                2923,
                 "Cannot sync because syncing is turned off on this machine from another machine."
             )), UserDataSyncErrorCode.TurnedOff));
         }

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

@@ -2,25 +2,14 @@
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 
 function merge(local, remote, lastSync, ignored) {
-    const localResult = {
-        added: [],
-        removed: [],
-        updated: []
-    };
-    let remoteResult = {
-        added: [],
-        removed: [],
-        updated: []
-    };
+    const localResult = { added: [], removed: [], updated: [] };
+    let remoteResult = { added: [], removed: [], updated: [] };
     if (!remote) {
-        const added = local.filter((
-            {
-                id
-            }
-        ) => !ignored.includes(id));
+        const added = local.filter(({ id }) => !ignored.includes(id));
         if (added.length) {
             remoteResult.added = added;
-        } else {
+        }
+        else {
             remoteResult = null;
         }
         return {
@@ -44,7 +33,8 @@ function merge(local, remote, lastSync, ignored) {
                 if (localToRemote.updated.includes(id)) {
                     localResult.updated.push(remoteProfile);
                 }
-            } else {
+            }
+            else {
                 localResult.added.push(remoteProfile);
             }
         }
@@ -74,54 +64,29 @@ function merge(local, remote, lastSync, ignored) {
     if (remoteResult.added.length === 0 && remoteResult.removed.length === 0 && remoteResult.updated.length === 0) {
         remoteResult = null;
     }
-    return {
-        local: localResult,
-        remote: remoteResult
-    };
+    return { local: localResult, remote: remoteResult };
 }
 function compare(from, to, ignoredProfiles) {
-    from = from ? from.filter((
-        {
-            id
-        }
-    ) => !ignoredProfiles.includes(id)) : [];
-    to = to.filter((
-        {
-            id
-        }
-    ) => !ignoredProfiles.includes(id));
-    const fromKeys = ( from.map((
-        {
-            id
-        }
-    ) => id));
-    const toKeys = ( to.map((
-        {
-            id
-        }
-    ) => id));
+    from = from ? from.filter(({ id }) => !ignoredProfiles.includes(id)) : [];
+    to = to.filter(({ id }) => !ignoredProfiles.includes(id));
+    const fromKeys = from.map(({ id }) => id);
+    const toKeys = to.map(({ id }) => id);
     const added = toKeys.filter(key => !fromKeys.includes(key));
     const removed = fromKeys.filter(key => !toKeys.includes(key));
     const updated = [];
-    for (const {
-        id,
-        name,
-        icon,
-        useDefaultFlags
-    } of from) {
+    for (const { id, name, icon, useDefaultFlags } of from) {
         if (removed.includes(id)) {
             continue;
         }
         const toProfile = to.find(p => p.id === id);
-        if (!toProfile || toProfile.name !== name || toProfile.icon !== icon || !equals(toProfile.useDefaultFlags, useDefaultFlags)) {
+        if (!toProfile
+            || toProfile.name !== name
+            || toProfile.icon !== icon
+            || !equals(toProfile.useDefaultFlags, useDefaultFlags)) {
             updated.push(id);
         }
     }
-    return {
-        added,
-        removed,
-        updated
-    };
+    return { added, removed, updated };
 }
 
 export { merge };

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

@@ -200,20 +200,20 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
         }
         if (localChange !== Change.None) {
             await this.backupLocal(stringifyLocalProfiles(this.getLocalUserDataProfiles(), false));
-            await Promise.all(( local.removed.map(async profile => {
+            await Promise.all(local.removed.map(async profile => {
                 this.logService.trace(`${this.syncResourceLogLabel}: Removing '${profile.name}' profile...`);
                 await this.userDataProfilesService.removeProfile(profile);
                 this.logService.info(`${this.syncResourceLogLabel}: Removed profile '${profile.name}'.`);
-            })));
-            await Promise.all(( local.added.map(async profile => {
+            }));
+            await Promise.all(local.added.map(async profile => {
                 this.logService.trace(`${this.syncResourceLogLabel}: Creating '${profile.name}' profile...`);
                 await this.userDataProfilesService.createProfile(profile.id, profile.name, {
                     icon: profile.icon,
                     useDefaultFlags: profile.useDefaultFlags
                 });
                 this.logService.info(`${this.syncResourceLogLabel}: Created profile '${profile.name}'.`);
-            })));
-            await Promise.all(( local.updated.map(async profile => {
+            }));
+            await Promise.all(local.updated.map(async profile => {
                 const localProfile = this.userDataProfilesService.profiles.find(p => p.id === profile.id);
                 if (localProfile) {
                     this.logService.trace(`${this.syncResourceLogLabel}: Updating '${profile.name}' profile...`);
@@ -228,7 +228,7 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
                         `${this.syncResourceLogLabel}: Could not find profile with id '${profile.id}' to update.`
                     );
                 }
-            })));
+            }));
         }
         if (remoteChange !== Change.None) {
             this.logService.trace(`${this.syncResourceLogLabel}: Updating remote profiles...`);
@@ -280,7 +280,7 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
             try {
                 remoteUserData = await this.updateRemoteProfiles(remoteProfiles, force ? null : remoteUserData.ref);
                 this.logService.info(
-                    `${this.syncResourceLogLabel}: Updated remote profiles.${canAddRemoteProfiles && remote?.added.length ? ` Added: ${JSON.stringify(( remote.added.map(e => e.name)))}.` : ""}${remote?.updated.length ? ` Updated: ${JSON.stringify(( remote.updated.map(e => e.name)))}.` : ""}${remote?.removed.length ? ` Removed: ${JSON.stringify(( remote.removed.map(e => e.name)))}.` : ""}`
+                    `${this.syncResourceLogLabel}: Updated remote profiles.${canAddRemoteProfiles && remote?.added.length ? ` Added: ${JSON.stringify(remote.added.map(e => e.name))}.` : ""}${remote?.updated.length ? ` Updated: ${JSON.stringify(remote.updated.map(e => e.name))}.` : ""}${remote?.removed.length ? ` Removed: ${JSON.stringify(remote.removed.map(e => e.name))}.` : ""}`
                 );
             } catch (error) {
                 if (addedCollections.length) {
@@ -325,10 +325,10 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
 };
 UserDataProfilesManifestSynchroniser = ( __decorate([( __param(2, IUserDataProfilesService)), ( __param(3, IFileService)), ( __param(4, IEnvironmentService)), ( __param(5, IStorageService)), ( __param(6, IUserDataSyncStoreService)), ( __param(7, IUserDataSyncLocalStoreService)), ( __param(8, IUserDataSyncLogService)), ( __param(9, IConfigurationService)), ( __param(10, IUserDataSyncEnablementService)), ( __param(11, ITelemetryService)), ( __param(12, IUriIdentityService))], UserDataProfilesManifestSynchroniser));
 function stringifyLocalProfiles(profiles, format) {
-    const result = ( [...profiles].sort((a, b) => a.name.localeCompare(b.name)).map(p => ({
+    const result = [...profiles].sort((a, b) => a.name.localeCompare(b.name)).map(p => ({
         id: p.id,
         name: p.name
-    })));
+    }));
     return format ? toFormattedString(result, {}) : JSON.stringify(result);
 }
 function parseUserDataProfilesManifest(syncData) {

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

@@ -71,10 +71,10 @@ let UserDataSyncLocalStoreService = class UserDataSyncLocalStoreService extends
             const stat = await this.fileService.resolve(folder);
             if (stat.children) {
                 const all = stat.children.filter(stat => stat.isFile && !stat.name.startsWith("lastSync")).sort().reverse();
-                return ( all.map(stat => ({
+                return all.map(stat => ({
                     ref: stat.name,
                     created: this.getCreationTime(stat)
-                })));
+                }));
             }
         } catch (error) {
             if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
@@ -124,10 +124,10 @@ let UserDataSyncLocalStoreService = class UserDataSyncLocalStoreService extends
                 if (remaining < 10) {
                     toDelete = toDelete.slice(10 - remaining);
                 }
-                await Promises.settled(( toDelete.map(async stat => {
+                await Promises.settled(toDelete.map(async stat => {
                     this.logService.info("Deleting from backup", stat.resource.path);
                     await this.fileService.del(stat.resource);
-                })));
+                }));
             }
         } catch (e) {
             this.logService.error(e);

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

@@ -13,7 +13,7 @@ let UserDataSyncLogService = class UserDataSyncLogService extends AbstractLogger
         this.logger = this._register(
             loggerService.createLogger(joinPath(environmentService.logsHome, `${USER_DATA_SYNC_LOG_ID}.log`), {
                 id: USER_DATA_SYNC_LOG_ID,
-                name: ( localize(2911, "Settings Sync"))
+                name: ( localize(2929, "Settings Sync"))
             })
         );
     }

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

@@ -87,17 +87,17 @@ let UserDataSyncResourceProviderService = class UserDataSyncResourceProviderServ
             const content = await this.userDataSyncLocalStoreService.resolveResourceContent("machines", refs[0].ref, undefined, location);
             if (content) {
                 const machinesData = JSON.parse(content);
-                return ( machinesData.machines.map(m => ({
+                return machinesData.machines.map(m => ({
                     ...m,
                     isCurrent: false
-                })));
+                }));
             }
         }
         return [];
     }
     async getRemoteSyncResourceHandles(syncResource, profile) {
         const handles = await this.userDataSyncStoreService.getAllResourceRefs(syncResource, profile?.collection);
-        return ( handles.map((
+        return handles.map((
             {
                 created,
                 ref
@@ -113,11 +113,11 @@ let UserDataSyncResourceProviderService = class UserDataSyncResourceProviderServ
                 ref,
                 node: undefined
             })
-        })));
+        }));
     }
     async getLocalSyncResourceHandles(syncResource, profile, location) {
         const handles = await this.userDataSyncLocalStoreService.getAllResourceRefs(syncResource, profile?.collection, location);
-        return ( handles.map((
+        return handles.map((
             {
                 created,
                 ref
@@ -133,7 +133,7 @@ let UserDataSyncResourceProviderService = class UserDataSyncResourceProviderServ
                 node: undefined,
                 location
             })
-        })));
+        }));
     }
     resolveUserDataSyncResource(
         {
@@ -580,7 +580,7 @@ let UserDataSyncResourceProviderService = class UserDataSyncResourceProviderServ
             this.logService.error(error);
         }
         throw ( new UserDataSyncError(( localize(
-            2913,
+            2931,
             "Cannot parse sync data as it is not compatible with the current version."
         )), UserDataSyncErrorCode.IncompatibleRemoteContent, syncResource));
     }

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

@@ -289,15 +289,17 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
     }
     async syncProfile(profileSynchronizer, manifestOrLatestData, preview, executionId, token) {
         const errors = await profileSynchronizer.sync(manifestOrLatestData, preview, executionId, token);
-        return ( errors.map(([syncResource, error]) => ({
+        return errors.map(([syncResource, error]) => ({
             profile: profileSynchronizer.profile,
             syncResource,
             error
-        })));
+        }));
     }
     async stop() {
         if (this.status !== SyncStatus.Idle) {
-            await Promise.allSettled(( this.getActiveProfileSynchronizers().map(profileSynchronizer => profileSynchronizer.stop())));
+            await Promise.allSettled(
+                this.getActiveProfileSynchronizers().map(profileSynchronizer => profileSynchronizer.stop())
+            );
         }
     }
     async resolveContent(resource) {
@@ -438,14 +440,14 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
     }
     async cleanUpRemoteData() {
         const remoteProfiles = await this.userDataSyncResourceProviderService.getRemoteSyncedProfiles();
-        const remoteProfileCollections = ( remoteProfiles.map(profile => profile.collection));
+        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(
+            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));
@@ -554,7 +556,7 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
         }
     }
     updateConflicts() {
-        const conflicts = ( this.getActiveProfileSynchronizers().map(synchronizer => synchronizer.conflicts)).flat();
+        const conflicts = this.getActiveProfileSynchronizers().map(synchronizer => synchronizer.conflicts).flat();
         if (!equals(
             this._conflicts,
             conflicts,
@@ -624,7 +626,7 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
 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));
+        return this._enabled.sort((a, b) => a[1] - b[1]).map(([synchronizer]) => synchronizer);
     }
     get disabled() {
         return ALL_SYNC_RESOURCES.filter(
@@ -874,7 +876,7 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
         return this.setStatus(SyncStatus.Idle);
     }
     updateConflicts() {
-        const conflicts = ( this.enabled.filter(s => s.status === SyncStatus.HasConflicts).filter(s => s.conflicts.conflicts.length > 0).map(s => s.conflicts));
+        const conflicts = this.enabled.filter(s => s.status === SyncStatus.HasConflicts).filter(s => s.conflicts.conflicts.length > 0).map(s => s.conflicts);
         if (!equals(
             this._conflicts,
             conflicts,

package/vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js

@@ -39,11 +39,11 @@ let UserDataSyncReportIssueContribution = class UserDataSyncReportIssueContribut
         case UserDataSyncErrorCode.LocalTooManyRequests:
             {
                 const message = isWeb ? ( localize(
-                    18598,
+                    20741,
                     "Settings sync is suspended temporarily because the current device is making too many requests. Please reload {0} to resume.",
                     this.productService.nameLong
                 )) : ( localize(
-                    18599,
+                    20742,
                     "Settings sync is suspended temporarily because the current device is making too many requests. Please restart {0} to resume.",
                     this.productService.nameLong
                 ));
@@ -53,11 +53,11 @@ let UserDataSyncReportIssueContribution = class UserDataSyncReportIssueContribut
                     actions: {
                         primary: [toAction({
                             id: "Show Sync Logs",
-                            label: ( localize(18600, "Show Log")),
+                            label: ( localize(20743, "Show Log")),
                             run: () => this.commandService.executeCommand(SHOW_SYNC_LOG_COMMAND_ID)
                         }), toAction({
                             id: "Restart",
-                            label: isWeb ? ( localize(18601, "Reload")) : ( localize(18602, "Restart")),
+                            label: isWeb ? ( localize(20744, "Reload")) : ( localize(20745, "Restart")),
                             run: () => this.hostService.restart()
                         })]
                     }
@@ -66,19 +66,19 @@ let UserDataSyncReportIssueContribution = class UserDataSyncReportIssueContribut
             }
         case UserDataSyncErrorCode.TooManyRequests:
             {
-                const operationId = error.operationId ? ( localize(18603, "Operation Id: {0}", error.operationId)) : undefined;
+                const operationId = error.operationId ? ( localize(20746, "Operation Id: {0}", error.operationId)) : undefined;
                 const message = ( localize(
-                    18604,
+                    20747,
                     "Settings sync is disabled because the current device is making too many requests. Please wait for 10 minutes and turn on sync."
                 ));
                 this.notificationService.notify({
                     severity: Severity.Error,
                     message: operationId ? `${message} ${operationId}` : message,
-                    source: error.operationId ? ( localize(18605, "Settings Sync. Operation Id: {0}", error.operationId)) : undefined,
+                    source: error.operationId ? ( localize(20748, "Settings Sync. Operation Id: {0}", error.operationId)) : undefined,
                     actions: {
                         primary: [toAction({
                             id: "Show Sync Logs",
-                            label: ( localize(18600, "Show Log")),
+                            label: ( localize(20743, "Show Log")),
                             run: () => this.commandService.executeCommand(SHOW_SYNC_LOG_COMMAND_ID)
                         })]
                     }