@codingame/monaco-vscode-user-data-sync-service-override 13.1.7 → 14.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-user-data-sync-service-override",
-  "version": "13.1.7",
+  "version": "14.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - user-data-sync service-override",
   "keywords": [],
@@ -15,20 +15,19 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-3607c442-ae7a-594b-b840-038378c24fef-common": "13.1.7",
-    "@codingame/monaco-vscode-411e0589-fa79-504b-b32c-80a88847b23a-common": "13.1.7",
-    "@codingame/monaco-vscode-4a316137-39d1-5d77-8b53-112db3547c1e-common": "13.1.7",
-    "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common": "13.1.7",
-    "@codingame/monaco-vscode-897bebad-39df-57cb-8a57-36a271d038be-common": "13.1.7",
-    "@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common": "13.1.7",
-    "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common": "13.1.7",
-    "@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common": "13.1.7",
-    "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common": "13.1.7",
-    "@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common": "13.1.7",
-    "@codingame/monaco-vscode-api": "13.1.7",
-    "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common": "13.1.7",
-    "@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common": "13.1.7",
-    "@codingame/monaco-vscode-user-data-profile-service-override": "13.1.7"
+    "@codingame/monaco-vscode-3607c442-ae7a-594b-b840-038378c24fef-common": "14.0.0",
+    "@codingame/monaco-vscode-407531d3-fdae-5387-8c41-49ba0e9574b5-common": "14.0.0",
+    "@codingame/monaco-vscode-411e0589-fa79-504b-b32c-80a88847b23a-common": "14.0.0",
+    "@codingame/monaco-vscode-4a316137-39d1-5d77-8b53-112db3547c1e-common": "14.0.0",
+    "@codingame/monaco-vscode-897bebad-39df-57cb-8a57-36a271d038be-common": "14.0.0",
+    "@codingame/monaco-vscode-91789cdf-e3cb-5a04-aaeb-6f7df7d3d231-common": "14.0.0",
+    "@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common": "14.0.0",
+    "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common": "14.0.0",
+    "@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common": "14.0.0",
+    "@codingame/monaco-vscode-api": "14.0.0",
+    "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common": "14.0.0",
+    "@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common": "14.0.0",
+    "@codingame/monaco-vscode-user-data-profile-service-override": "14.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/userDataSync/common/userDataAutoSyncService.d.ts

@@ -3,7 +3,7 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-import { UserDataSyncError } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync";
+import { UserDataSyncError, SyncOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync";
 import { IUserDataSyncLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service";
 import { IUserDataAutoSyncService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service";
 import { IUserDataSyncService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service";
@@ -49,6 +49,6 @@ export declare class UserDataAutoSyncService extends Disposable implements IUser
     private hasToDisableMachineEventually;
     private stopDisableMachineEventually;
     private sources;
-    triggerSync(sources: string[], skipIfSyncedRecently: boolean, disableCache: boolean): Promise<void>;
+    triggerSync(sources: string[], options?: SyncOptions): Promise<void>;
     protected getSyncTriggerDelayTime(): number;
 }

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

@@ -14,7 +14,7 @@ import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { UserDataSyncError, UserDataAutoSyncError, UserDataSyncErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
+import { UserDataSyncError, UserDataSyncErrorCode, UserDataAutoSyncError } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreManagementService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
 import { IUserDataSyncAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
 import { IUserDataSyncMachinesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
@@ -71,21 +71,21 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
         this.previousProductQuality = this.productQuality;
         this.productQuality = productService.quality;
         if (this.syncUrl) {
-            this.logService.info('Using settings sync service', ( this.syncUrl.toString()));
+            this.logService.info('[AutoSync] Using settings sync service', ( this.syncUrl.toString()));
             this._register(userDataSyncStoreManagementService.onDidChangeUserDataSyncStore(() => {
                 if (!isEqual(this.syncUrl, userDataSyncStoreManagementService.userDataSyncStore?.url)) {
                     this.lastSyncUrl = this.syncUrl;
                     this.syncUrl = userDataSyncStoreManagementService.userDataSyncStore?.url;
                     if (this.syncUrl) {
-                        this.logService.info('Using settings sync service', ( this.syncUrl.toString()));
+                        this.logService.info('[AutoSync] Using settings sync service', ( this.syncUrl.toString()));
                     }
                 }
             }));
             if (this.userDataSyncEnablementService.isEnabled()) {
-                this.logService.info('Auto Sync is enabled.');
+                this.logService.info('[AutoSync] Enabled.');
             }
             else {
-                this.logService.info('Auto Sync is disabled.');
+                this.logService.info('[AutoSync] Disabled.');
             }
             this.updateAutoSync();
             if (this.hasToDisableMachineEventually()) {
@@ -93,9 +93,9 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
             }
             this._register(userDataSyncAccountService.onDidChangeAccount(() => this.updateAutoSync()));
             this._register(userDataSyncStoreService.onDidChangeDonotMakeRequestsUntil(() => this.updateAutoSync()));
-            this._register(userDataSyncService.onDidChangeLocal(source => this.triggerSync([source], false, false)));
-            this._register(Event.filter(this.userDataSyncEnablementService.onDidChangeResourceEnablement, ([, enabled]) => enabled)(() => this.triggerSync(['resourceEnablement'], false, false)));
-            this._register(this.userDataSyncStoreManagementService.onDidChangeUserDataSyncStore(() => this.triggerSync(['userDataSyncStoreChanged'], false, false)));
+            this._register(userDataSyncService.onDidChangeLocal(source => this.triggerSync([source])));
+            this._register(Event.filter(this.userDataSyncEnablementService.onDidChangeResourceEnablement, ([, enabled]) => enabled)(() => this.triggerSync(['resourceEnablement'])));
+            this._register(this.userDataSyncStoreManagementService.onDidChangeUserDataSyncStore(() => this.triggerSync(['userDataSyncStoreChanged'])));
         }
     }
     updateAutoSync() {
@@ -136,16 +136,16 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
     startAutoSync() { return true; }
     isAutoSyncEnabled() {
         if (!this.userDataSyncEnablementService.isEnabled()) {
-            return { enabled: false, message: 'Auto Sync: Disabled.' };
+            return { enabled: false, message: '[AutoSync] Disabled.' };
         }
         if (!this.userDataSyncAccountService.account) {
-            return { enabled: false, message: 'Auto Sync: Suspended until auth token is available.' };
+            return { enabled: false, message: '[AutoSync] Suspended until auth token is available.' };
         }
         if (this.userDataSyncStoreService.donotMakeRequestsUntil) {
-            return { enabled: false, message: `Auto Sync: Suspended until ${toLocalISOString(this.userDataSyncStoreService.donotMakeRequestsUntil)} because server is not accepting requests until then.` };
+            return { enabled: false, message: `[AutoSync] Suspended until ${toLocalISOString(this.userDataSyncStoreService.donotMakeRequestsUntil)} because server is not accepting requests until then.` };
         }
         if (this.suspendUntilRestart) {
-            return { enabled: false, message: 'Auto Sync: Suspended until restart.' };
+            return { enabled: false, message: '[AutoSync] Suspended until restart.' };
         }
         return { enabled: true };
     }
@@ -162,7 +162,6 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
             this.updateEnablement(false);
             this.storageService.remove(sessionIdKey, StorageScope.APPLICATION);
             if (everywhere) {
-                this.telemetryService.publicLog2('sync/turnOffEveryWhere');
                 await this.userDataSyncService.reset();
             }
             else {
@@ -189,58 +188,56 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
         return !!this.previousProductQuality && !!this.productQuality && this.previousProductQuality !== this.productQuality;
     }
     async onDidFinishSync(error) {
+        this.logService.debug('[AutoSync] Sync Finished');
         if (!error) {
             this.successiveFailures = 0;
             return;
         }
         const userDataSyncError = UserDataSyncError.toUserDataSyncError(error);
-        if (userDataSyncError instanceof UserDataAutoSyncError) {
-            this.telemetryService.publicLog2(`autosync/error`, { code: userDataSyncError.code, service: ( this.userDataSyncStoreManagementService.userDataSyncStore.url.toString()) });
-        }
         if (userDataSyncError.code === UserDataSyncErrorCode.SessionExpired) {
             await this.turnOff(false, true );
-            this.logService.info('Auto Sync: Turned off sync because current session is expired');
+            this.logService.info('[AutoSync] Turned off sync because current session is expired');
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.TurnedOff) {
             await this.turnOff(false, true );
-            this.logService.info('Auto Sync: Turned off sync because sync is turned off in the cloud');
+            this.logService.info('[AutoSync] Turned off sync because sync is turned off in the cloud');
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.LocalTooManyRequests) {
             this.suspendUntilRestart = true;
-            this.logService.info('Auto Sync: Suspended sync because of making too many requests to server');
+            this.logService.info('[AutoSync] Suspended sync because of making too many requests to server');
             this.updateAutoSync();
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.TooManyRequests) {
             await this.turnOff(false, true , true );
             this.disableMachineEventually();
-            this.logService.info('Auto Sync: Turned off sync because of making too many requests to server');
+            this.logService.info('[AutoSync] Turned off sync because of making too many requests to server');
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.MethodNotFound) {
             await this.turnOff(false, true );
-            this.logService.info('Auto Sync: Turned off sync because current client is making requests to server that are not supported');
+            this.logService.info('[AutoSync] Turned off sync because current client is making requests to server that are not supported');
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.UpgradeRequired || userDataSyncError.code === UserDataSyncErrorCode.Gone) {
             await this.turnOff(false, true , true );
             this.disableMachineEventually();
-            this.logService.info('Auto Sync: Turned off sync because current client is not compatible with server. Requires client upgrade.');
+            this.logService.info('[AutoSync] Turned off sync because current client is not compatible with server. Requires client upgrade.');
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.IncompatibleLocalContent) {
             await this.turnOff(false, true );
-            this.logService.info(`Auto Sync: Turned off sync because server has ${userDataSyncError.resource} content with newer version than of client. Requires client upgrade.`);
+            this.logService.info(`[AutoSync] Turned off sync because server has ${userDataSyncError.resource} content with newer version than of client. Requires client upgrade.`);
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.IncompatibleRemoteContent) {
             await this.turnOff(false, true );
-            this.logService.info(`Auto Sync: Turned off sync because server has ${userDataSyncError.resource} content with older version than of client. Requires server reset.`);
+            this.logService.info(`[AutoSync] Turned off sync because server has ${userDataSyncError.resource} content with older version than of client. Requires server reset.`);
         }
         else if (userDataSyncError.code === UserDataSyncErrorCode.ServiceChanged || userDataSyncError.code === UserDataSyncErrorCode.DefaultServiceChanged) {
             if (isWeb && userDataSyncError.code === UserDataSyncErrorCode.DefaultServiceChanged && !this.hasProductQualityChanged()) {
                 await this.turnOff(false, true );
-                this.logService.info('Auto Sync: Turned off sync because default sync service is changed.');
+                this.logService.info('[AutoSync] Turned off sync because default sync service is changed.');
             }
             else {
                 await this.turnOff(false, true , true );
                 await this.turnOn();
-                this.logService.info('Auto Sync: Sync Service changed. Turned off auto sync, reset local state and turned on auto sync.');
+                this.logService.info('[AutoSync] Sync Service changed. Turned off auto sync, reset local state and turned on auto sync.');
             }
         }
         else {
@@ -266,30 +263,31 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
     stopDisableMachineEventually() {
         this.storageService.remove(disableMachineEventuallyKey, StorageScope.APPLICATION);
     }
-    async triggerSync(sources, skipIfSyncedRecently, disableCache) {
+    async triggerSync(sources, options) {
         if (this.autoSync.value === undefined) {
             return this.syncTriggerDelayer.cancel();
         }
-        if (skipIfSyncedRecently && this.lastSyncTriggerTime
-            && Math.round((( new Date()).getTime() - this.lastSyncTriggerTime) / 1000) < 10) {
-            this.logService.debug('Auto Sync: Skipped. Limited to once per 10 seconds.');
+        if (options?.skipIfSyncedRecently && this.lastSyncTriggerTime && ( new Date()).getTime() - this.lastSyncTriggerTime < 10_000) {
+            this.logService.debug('[AutoSync] Skipping because sync was triggered recently.', sources);
             return;
         }
         this.sources.push(...sources);
         return this.syncTriggerDelayer.trigger(async () => {
-            this.logService.trace('activity sources', ...this.sources);
-            const providerId = this.userDataSyncAccountService.account?.authenticationProviderId || '';
-            this.telemetryService.publicLog2('sync/triggered', { sources: this.sources, providerId });
+            this.logService.trace('[AutoSync] Activity sources', ...this.sources);
             this.sources = [];
             if (this.autoSync.value) {
-                await this.autoSync.value.sync('Activity', disableCache);
+                await this.autoSync.value.sync('Activity', !!options?.disableCache);
             }
         }, this.successiveFailures
-            ? this.getSyncTriggerDelayTime() * 1 * Math.min(Math.pow(2, this.successiveFailures), 60)
-            : this.getSyncTriggerDelayTime());
+            ? Math.min(this.getSyncTriggerDelayTime() * this.successiveFailures, 60_000)
+            : options?.immediately ? 0 : this.getSyncTriggerDelayTime());
     }
     getSyncTriggerDelayTime() {
-        return 2000;
+        if (this.lastSyncTriggerTime && ( new Date()).getTime() - this.lastSyncTriggerTime > 10_000) {
+            this.logService.debug('[AutoSync] Sync immediately because last sync was triggered more than 10 seconds ago.');
+            return 0;
+        }
+        return 3_000;
     }
 };
 UserDataAutoSyncService = ( __decorate([
@@ -329,11 +327,11 @@ class AutoSync extends Disposable {
         this._register(toDisposable(() => {
             if (this.syncPromise) {
                 this.syncPromise.cancel();
-                this.logService.info('Auto sync: Cancelled sync that is in progress');
+                this.logService.info('[AutoSync] Cancelled sync that is in progress');
                 this.syncPromise = undefined;
             }
             this.syncTask?.stop();
-            this.logService.info('Auto Sync: Stopped');
+            this.logService.info('[AutoSync] Stopped');
         }));
         this.sync(AutoSync.INTERVAL_SYNCING, false);
     }
@@ -347,7 +345,7 @@ class AutoSync extends Disposable {
         const syncPromise = createCancelablePromise(async (token) => {
             if (this.syncPromise) {
                 try {
-                    this.logService.debug('Auto Sync: Waiting until sync is finished.');
+                    this.logService.debug('[AutoSync] Waiting until sync is finished.');
                     await this.syncPromise;
                 }
                 catch (error) {
@@ -374,7 +372,7 @@ class AutoSync extends Disposable {
                 !isEqual(current.stableUrl, previous.stableUrl));
     }
     async doSync(reason, disableCache, token) {
-        this.logService.info(`Auto Sync: Triggered by ${reason}`);
+        this.logService.info(`[AutoSync] Triggered by ${reason}`);
         this._onDidStartSync.fire();
         let error;
         try {
@@ -385,9 +383,9 @@ class AutoSync extends Disposable {
             error = e;
             if (UserDataSyncError.toUserDataSyncError(e).code === UserDataSyncErrorCode.MethodNotFound) {
                 try {
-                    this.logService.info('Auto Sync: Client is making invalid requests. Cleaning up data...');
+                    this.logService.info('[AutoSync] Client is making invalid requests. Cleaning up data...');
                     await this.userDataSyncService.cleanUpRemoteData();
-                    this.logService.info('Auto Sync: Retrying sync...');
+                    this.logService.info('[AutoSync] Retrying sync...');
                     await this.createAndRunSyncTask(disableCache, token);
                     error = undefined;
                 }
@@ -408,28 +406,28 @@ class AutoSync extends Disposable {
         if (this.manifest === null && (await this.userDataSyncService.hasPreviouslySynced())) {
             if (this.hasSyncServiceChanged()) {
                 if (await this.hasDefaultServiceChanged()) {
-                    throw ( new UserDataAutoSyncError(( localize(2248, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2288, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 }
                 else {
-                    throw ( new UserDataAutoSyncError(( localize(2249, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2289, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             }
             else {
-                throw ( new UserDataAutoSyncError(( localize(2250, "Cannot sync because syncing is turned off in the cloud")), UserDataSyncErrorCode.TurnedOff));
+                throw ( new UserDataAutoSyncError(( localize(2290, "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(2248, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2288, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 }
                 else {
-                    throw ( new UserDataAutoSyncError(( localize(2249, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
+                    throw ( new UserDataAutoSyncError(( localize(2289, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             }
             else {
-                throw ( new UserDataAutoSyncError(( localize(2251, "Cannot sync because current session is expired")), UserDataSyncErrorCode.SessionExpired));
+                throw ( new UserDataAutoSyncError(( localize(2291, "Cannot sync because current session is expired")), UserDataSyncErrorCode.SessionExpired));
             }
         }
         const machines = await this.userDataSyncMachinesService.getMachines(this.manifest || undefined);
@@ -439,7 +437,7 @@ class AutoSync extends Disposable {
         const currentMachine = machines.find(machine => machine.isCurrent);
         if (currentMachine?.disabled) {
             throw ( new UserDataAutoSyncError(( localize(
-                2252,
+                2292,
                 "Cannot sync because syncing is turned off on this machine from another machine."
             )), UserDataSyncErrorCode.TurnedOff));
         }

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { toFormattedString } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/base/common/jsonFormatter';
+import { toFormattedString } from '@codingame/monaco-vscode-407531d3-fdae-5387-8c41-49ba0e9574b5-common/vscode/vs/base/common/jsonFormatter';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';

package/vscode/src/vs/platform/userDataSync/common/userDataSyncEnablementService.d.ts

@@ -2,13 +2,11 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { SyncResource } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync";
 import { IUserDataSyncEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service";
 import { IUserDataSyncStoreManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service";
 export declare class UserDataSyncEnablementService extends Disposable implements IUserDataSyncEnablementService {
     private readonly storageService;
-    private readonly telemetryService;
     protected readonly environmentService: IEnvironmentService;
     private readonly userDataSyncStoreManagementService;
     _serviceBrand: any;
@@ -19,7 +17,7 @@ export declare class UserDataSyncEnablementService extends Disposable implements
         SyncResource,
         boolean
     ]>;
-    constructor(storageService: IStorageService, telemetryService: ITelemetryService, environmentService: IEnvironmentService, userDataSyncStoreManagementService: IUserDataSyncStoreManagementService);
+    constructor(storageService: IStorageService, environmentService: IEnvironmentService, userDataSyncStoreManagementService: IUserDataSyncStoreManagementService);
     isEnabled(): boolean;
     canToggleEnablement(): boolean;
     setEnablement(enabled: boolean): void;

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

@@ -6,16 +6,14 @@ import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platfo
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { getEnablementKey, ALL_SYNC_RESOURCES } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
 
 const enablementKey = 'sync.enable';
 let UserDataSyncEnablementService$1 = class UserDataSyncEnablementService extends Disposable {
-    constructor(storageService, telemetryService, environmentService, userDataSyncStoreManagementService) {
+    constructor(storageService, environmentService, userDataSyncStoreManagementService) {
         super();
         this.storageService = storageService;
-        this.telemetryService = telemetryService;
         this.environmentService = environmentService;
         this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
         this._onDidChangeEnablement = ( new Emitter());
@@ -40,7 +38,6 @@ let UserDataSyncEnablementService$1 = class UserDataSyncEnablementService extend
         if (enabled && !this.canToggleEnablement()) {
             return;
         }
-        this.telemetryService.publicLog2(enablementKey, { enabled });
         this.storageService.store(enablementKey, enabled, StorageScope.APPLICATION, StorageTarget.MACHINE);
     }
     isResourceEnabled(resource) {
@@ -72,9 +69,8 @@ let UserDataSyncEnablementService$1 = class UserDataSyncEnablementService extend
 };
 UserDataSyncEnablementService$1 = ( __decorate([
     ( __param(0, IStorageService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IEnvironmentService)),
-    ( __param(3, IUserDataSyncStoreManagementService))
+    ( __param(1, IEnvironmentService)),
+    ( __param(2, IUserDataSyncStoreManagementService))
 ], UserDataSyncEnablementService$1));
 
 export { UserDataSyncEnablementService$1 as UserDataSyncEnablementService };

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

@@ -10,7 +10,7 @@ import { USER_DATA_SYNC_LOG_ID } from '@codingame/monaco-vscode-api/vscode/vs/pl
 let UserDataSyncLogService = class UserDataSyncLogService extends AbstractLogger {
     constructor(loggerService, environmentService) {
         super();
-        this.logger = this._register(loggerService.createLogger(joinPath(environmentService.logsHome, `${USER_DATA_SYNC_LOG_ID}.log`), { id: USER_DATA_SYNC_LOG_ID, name: ( localize(2258, "Settings Sync")) }));
+        this.logger = this._register(loggerService.createLogger(joinPath(environmentService.logsHome, `${USER_DATA_SYNC_LOG_ID}.log`), { id: USER_DATA_SYNC_LOG_ID, name: ( localize(2298, "Settings Sync")) }));
     }
     trace(message, ...args) {
         this.logger.trace(message, ...args);

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

@@ -20,7 +20,7 @@ import { stringify, parseExtensions, LocalExtensionsProvider } from '@codingame/
 import { stringify as stringify$1, LocalGlobalStateProvider } from '@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common/vscode/vs/platform/userDataSync/common/globalStateSync';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { parseUserDataProfilesManifest, stringifyLocalProfiles } from './userDataProfilesManifestSync.js';
-import { toFormattedString } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/base/common/jsonFormatter';
+import { toFormattedString } from '@codingame/monaco-vscode-407531d3-fdae-5387-8c41-49ba0e9574b5-common/vscode/vs/base/common/jsonFormatter';
 import { trim } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 
 var UserDataSyncResourceProviderService_1;
@@ -429,7 +429,7 @@ let UserDataSyncResourceProviderService = class UserDataSyncResourceProviderServ
             this.logService.error(error);
         }
         throw ( new UserDataSyncError(( localize(
-            2260,
+            2300,
             "Cannot parse sync data as it is not compatible with the current version."
         )), UserDataSyncErrorCode.IncompatibleRemoteContent, syncResource));
     }

package/vscode/src/vs/platform/userDataSync/common/userDataSyncService.d.ts

@@ -113,7 +113,7 @@ declare class ProfileSynchronizer extends Disposable {
     protected registerSynchronizer(syncResource: SyncResource): void;
     private deRegisterSynchronizer;
     createSynchronizer(syncResource: Exclude<SyncResource, SyncResource.WorkspaceState>): IUserDataSynchroniser & IDisposable;
-    sync(manifest: IUserDataManifest | null, merge: boolean, executionId: string, token: CancellationToken): Promise<[
+    sync(manifest: IUserDataManifest | null, preview: boolean, executionId: string, token: CancellationToken): Promise<[
         SyncResource,
         UserDataSyncError
     ][]>;
@@ -121,6 +121,7 @@ declare class ProfileSynchronizer extends Disposable {
     stop(): Promise<void>;
     resetLocal(): Promise<void>;
     private getUserDataSyncConfiguration;
+    private getLocalUserDataSyncConfiguration;
     private setStatus;
     private updateStatus;
     private updateConflicts;

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

@@ -24,7 +24,7 @@ import { SettingsSynchroniser } from '@codingame/monaco-vscode-a022e9a8-b522-5ea
 import { SnippetsSynchroniser } from '@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common/vscode/vs/platform/userDataSync/common/snippetsSync';
 import { TasksSynchroniser } from '@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common/vscode/vs/platform/userDataSync/common/tasksSync';
 import { UserDataProfilesManifestSynchroniser } from './userDataProfilesManifestSync.js';
-import { SyncStatus, createSyncHeaders, UserDataSyncError, UserDataSyncErrorCode, SyncResource, ALL_SYNC_RESOURCES, Change, MergeState, USER_DATA_SYNC_CONFIGURATION_SCOPE, UserDataSyncStoreError } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
+import { SyncStatus, createSyncHeaders, UserDataSyncError, UserDataSyncErrorCode, SyncResource, ALL_SYNC_RESOURCES, USER_DATA_SYNC_CONFIGURATION_SCOPE, UserDataSyncStoreError } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreService, IUserDataSyncStoreManagementService, IUserDataSyncLogService, IUserDataSyncEnablementService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
 
 const LAST_SYNC_TIME_KEY = 'sync.lastSyncTime';
@@ -162,21 +162,21 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
             }
         };
     }
-    async sync(manifest, merge, executionId, token) {
+    async sync(manifest, preview, executionId, token) {
         this._syncErrors = [];
         try {
             if (this.status !== SyncStatus.HasConflicts) {
                 this.setStatus(SyncStatus.Syncing);
             }
             const defaultProfileSynchronizer = this.getOrCreateActiveProfileSynchronizer(this.userDataProfilesService.defaultProfile, undefined);
-            this._syncErrors.push(...(await this.syncProfile(defaultProfileSynchronizer, manifest, merge, executionId, token)));
+            this._syncErrors.push(...(await this.syncProfile(defaultProfileSynchronizer, manifest, preview, executionId, token)));
             const userDataProfileManifestSynchronizer = defaultProfileSynchronizer.enabled.find(s => s.resource === SyncResource.Profiles);
             if (userDataProfileManifestSynchronizer) {
                 const syncProfiles = (await userDataProfileManifestSynchronizer.getLastSyncedProfiles()) || [];
                 if (token.isCancellationRequested) {
                     return;
                 }
-                await this.syncRemoteProfiles(syncProfiles, manifest, merge, executionId, token);
+                await this.syncRemoteProfiles(syncProfiles, manifest, preview, executionId, token);
             }
         }
         finally {
@@ -186,7 +186,7 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
             this._onSyncErrors.fire(this._syncErrors);
         }
     }
-    async syncRemoteProfiles(remoteProfiles, manifest, merge, executionId, token) {
+    async syncRemoteProfiles(remoteProfiles, manifest, preview, executionId, token) {
         for (const syncProfile of remoteProfiles) {
             if (token.isCancellationRequested) {
                 return;
@@ -198,7 +198,7 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
             }
             this.logService.info('Syncing profile.', syncProfile.name);
             const profileSynchronizer = this.getOrCreateActiveProfileSynchronizer(profile, syncProfile);
-            this._syncErrors.push(...(await this.syncProfile(profileSynchronizer, manifest, merge, executionId, token)));
+            this._syncErrors.push(...(await this.syncProfile(profileSynchronizer, manifest, preview, executionId, token)));
         }
         for (const [key, profileSynchronizerItem] of this.activeProfileSynchronizers.entries()) {
             if (( this.userDataProfilesService.profiles.some(p => p.id === profileSynchronizerItem[0].profile.id))) {
@@ -237,8 +237,8 @@ let UserDataSyncService = class UserDataSyncService extends Disposable {
             this.setStatus(SyncStatus.Idle);
         }
     }
-    async syncProfile(profileSynchronizer, manifest, merge, executionId, token) {
-        const errors = await profileSynchronizer.sync(manifest, merge, executionId, token);
+    async syncProfile(profileSynchronizer, manifest, preview, executionId, token) {
+        const errors = await profileSynchronizer.sync(manifest, preview, executionId, token);
         return ( errors.map(
             ([syncResource, error]) => ({ profile: profileSynchronizer.profile, syncResource, error })
         ));
@@ -640,7 +640,7 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
             case SyncResource.Profiles: return this.instantiationService.createInstance(UserDataProfilesManifestSynchroniser, this.profile, this.collection);
         }
     }
-    async sync(manifest, merge, executionId, token) {
+    async sync(manifest, preview, executionId, token) {
         if (token.isCancellationRequested) {
             return [];
         }
@@ -652,7 +652,7 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
             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) : {};
+            const userDataSyncConfiguration = preview ? await this.getUserDataSyncConfiguration(resourceManifest) : this.getLocalUserDataSyncConfiguration();
             for (const synchroniser of synchronizers) {
                 if (token.isCancellationRequested) {
                     return [];
@@ -661,19 +661,7 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
                     return [];
                 }
                 try {
-                    if (merge) {
-                        const preview = await synchroniser.preview(resourceManifest, userDataSyncConfiguration, syncHeaders);
-                        if (preview) {
-                            for (const resourcePreview of preview.resourcePreviews) {
-                                if ((resourcePreview.localChange !== Change.None || resourcePreview.remoteChange !== Change.None) && resourcePreview.mergeState === MergeState.Preview) {
-                                    await synchroniser.merge(resourcePreview.previewResource);
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        await synchroniser.sync(resourceManifest, syncHeaders);
-                    }
+                    await synchroniser.sync(resourceManifest, preview, userDataSyncConfiguration, syncHeaders);
                 }
                 catch (e) {
                     const userDataSyncError = UserDataSyncError.toUserDataSyncError(e);
@@ -739,7 +727,7 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
         if (!this.profile.isDefault) {
             return {};
         }
-        const local = this.configurationService.getValue(USER_DATA_SYNC_CONFIGURATION_SCOPE);
+        const local = this.getLocalUserDataSyncConfiguration();
         const settingsSynchronizer = this.enabled.find(synchronizer => synchronizer instanceof SettingsSynchroniser);
         if (settingsSynchronizer) {
             const remote = await settingsSynchronizer.getRemoteUserDataSyncConfiguration(manifest);
@@ -747,6 +735,9 @@ let ProfileSynchronizer = class ProfileSynchronizer extends Disposable {
         }
         return local;
     }
+    getLocalUserDataSyncConfiguration() {
+        return this.configurationService.getValue(USER_DATA_SYNC_CONFIGURATION_SCOPE);
+    }
     setStatus(status) {
         if (this._status !== status) {
             this._status = status;