@codingame/monaco-vscode-user-data-sync-service-override 11.1.2 → 12.0.1

package/index.d.ts

@@ -1 +1,2 @@
-export { default } from 'vscode/service-override/userDataSync';
+import type { IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -1 +1,37 @@
-export { default } from './userDataSync.js';
+
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IUserDataAutoSyncService, IUserDataSyncStoreManagementService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { UserDataSyncAccountService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js';
+import { IUserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
+import { UserDataSyncMachinesService } from '@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { IUserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
+import { UserDataSyncStoreManagementService, UserDataSyncStoreService } from '@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/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 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
+import getServiceOverride$1 from '@codingame/monaco-vscode-user-data-profile-service-override';
+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,8 @@
 {
   "name": "@codingame/monaco-vscode-user-data-sync-service-override",
-  "version": "11.1.2",
+  "version": "12.0.1",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - user-data-sync service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,29 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - user-data-sync service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common": "12.0.1",
+    "@codingame/monaco-vscode-3607c442-ae7a-594b-b840-038378c24fef-common": "12.0.1",
+    "@codingame/monaco-vscode-4a316137-39d1-5d77-8b53-112db3547c1e-common": "12.0.1",
+    "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common": "12.0.1",
+    "@codingame/monaco-vscode-897bebad-39df-57cb-8a57-36a271d038be-common": "12.0.1",
+    "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common": "12.0.1",
+    "@codingame/monaco-vscode-a022e9a8-b522-5ea2-97c7-f3dda2b0b597-common": "12.0.1",
+    "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common": "12.0.1",
+    "@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common": "12.0.1",
+    "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common": "12.0.1",
+    "@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common": "12.0.1",
+    "@codingame/monaco-vscode-user-data-profile-service-override": "12.0.1",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.1"
+  },
+  "peerDependencies": {
+    "@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common": "12.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common": {
+      "optional": true
+    }
+  },
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,12 +45,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2",
-    "@codingame/monaco-vscode-user-data-profile-service-override": "11.1.2",
-    "@codingame/monaco-vscode-user-data-profile-user-data-sync-common": "11.1.2"
   }
 }

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

@@ -0,0 +1,54 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { UserDataSyncError } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync";
+import { IUserDataSyncLogService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataAutoSyncService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncEnablementService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncStoreService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncStoreManagementService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncAccountService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service";
+import { IUserDataSyncMachinesService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service";
+export declare class UserDataAutoSyncService extends Disposable implements IUserDataAutoSyncService {
+    private readonly userDataSyncStoreManagementService;
+    private readonly userDataSyncStoreService;
+    private readonly userDataSyncEnablementService;
+    private readonly userDataSyncService;
+    private readonly logService;
+    private readonly userDataSyncAccountService;
+    private readonly telemetryService;
+    private readonly userDataSyncMachinesService;
+    private readonly storageService;
+    _serviceBrand: any;
+    private readonly autoSync;
+    private successiveFailures;
+    private lastSyncTriggerTime;
+    private readonly syncTriggerDelayer;
+    private suspendUntilRestart;
+    private readonly _onError;
+    readonly onError: Event<UserDataSyncError>;
+    private lastSyncUrl;
+    private get syncUrl();
+    private set syncUrl(value);
+    private previousProductQuality;
+    private get productQuality();
+    private set productQuality(value);
+    constructor(productService: IProductService, userDataSyncStoreManagementService: IUserDataSyncStoreManagementService, userDataSyncStoreService: IUserDataSyncStoreService, userDataSyncEnablementService: IUserDataSyncEnablementService, userDataSyncService: IUserDataSyncService, logService: IUserDataSyncLogService, userDataSyncAccountService: IUserDataSyncAccountService, telemetryService: ITelemetryService, userDataSyncMachinesService: IUserDataSyncMachinesService, storageService: IStorageService);
+    private updateAutoSync;
+    protected startAutoSync(): boolean;
+    private isAutoSyncEnabled;
+    turnOn(): Promise<void>;
+    turnOff(everywhere: boolean, softTurnOffOnError?: boolean, donotRemoveMachine?: boolean): Promise<void>;
+    private updateEnablement;
+    private hasProductQualityChanged;
+    private onDidFinishSync;
+    private disableMachineEventually;
+    private hasToDisableMachineEventually;
+    private stopDisableMachineEventually;
+    private sources;
+    triggerSync(sources: string[], skipIfSyncedRecently: boolean, disableCache: boolean): Promise<void>;
+    protected getSyncTriggerDelayTime(): number;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { ThrottledDelayer, timeout, disposableTimeout, createCancelablePromise } from 'vscode/vscode/vs/base/common/async';
 import { toLocalISOString } from 'vscode/vscode/vs/base/common/date';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
@@ -10,9 +11,10 @@ import { isEqual } from 'vscode/vscode/vs/base/common/resources';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-import { UserDataSyncError, UserDataAutoSyncError } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { UserDataSyncError, UserDataAutoSyncError, UserDataSyncErrorCode } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreManagementService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 import { IUserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
 import { IUserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
@@ -23,26 +25,26 @@ const storeUrlKey = 'sync.storeUrl';
 const productQualityKey = 'sync.productQuality';
 let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
     get syncUrl() {
-        const value = this.storageService.get(storeUrlKey, -1 );
+        const value = this.storageService.get(storeUrlKey, StorageScope.APPLICATION);
         return value ? ( URI.parse(value)) : undefined;
     }
     set syncUrl(syncUrl) {
         if (syncUrl) {
-            this.storageService.store(storeUrlKey, ( syncUrl.toString()), -1 , 1 );
+            this.storageService.store(storeUrlKey, ( syncUrl.toString()), StorageScope.APPLICATION, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(storeUrlKey, -1 );
+            this.storageService.remove(storeUrlKey, StorageScope.APPLICATION);
         }
     }
     get productQuality() {
-        return this.storageService.get(productQualityKey, -1 );
+        return this.storageService.get(productQualityKey, StorageScope.APPLICATION);
     }
     set productQuality(productQuality) {
         if (productQuality) {
-            this.storageService.store(productQualityKey, productQuality, -1 , 1 );
+            this.storageService.store(productQualityKey, productQuality, StorageScope.APPLICATION, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(productQualityKey, -1 );
+            this.storageService.remove(productQualityKey, StorageScope.APPLICATION);
         }
     }
     constructor(productService, userDataSyncStoreManagementService, userDataSyncStoreService, userDataSyncEnablementService, userDataSyncService, logService, userDataSyncAccountService, telemetryService, userDataSyncMachinesService, storageService) {
@@ -158,7 +160,7 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
                 await this.userDataSyncMachinesService.removeCurrentMachine();
             }
             this.updateEnablement(false);
-            this.storageService.remove(sessionIdKey, -1 );
+            this.storageService.remove(sessionIdKey, StorageScope.APPLICATION);
             if (everywhere) {
                 this.telemetryService.publicLog2('sync/turnOffEveryWhere');
                 await this.userDataSyncService.reset();
@@ -195,43 +197,43 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
         if (userDataSyncError instanceof UserDataAutoSyncError) {
             this.telemetryService.publicLog2(`autosync/error`, { code: userDataSyncError.code, service: ( this.userDataSyncStoreManagementService.userDataSyncStore.url.toString()) });
         }
-        if (userDataSyncError.code === "SessionExpired" ) {
+        if (userDataSyncError.code === UserDataSyncErrorCode.SessionExpired) {
             await this.turnOff(false, true );
             this.logService.info('Auto Sync: Turned off sync because current session is expired');
         }
-        else if (userDataSyncError.code === "TurnedOff" ) {
+        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');
         }
-        else if (userDataSyncError.code === "LocalTooManyRequests" ) {
+        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.updateAutoSync();
         }
-        else if (userDataSyncError.code === "RemoteTooManyRequests" ) {
+        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');
         }
-        else if (userDataSyncError.code === "MethodNotFound" ) {
+        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');
         }
-        else if (userDataSyncError.code === "UpgradeRequired"  || userDataSyncError.code === "Gone" ) {
+        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.');
         }
-        else if (userDataSyncError.code === "IncompatibleLocalContent" ) {
+        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.`);
         }
-        else if (userDataSyncError.code === "IncompatibleRemoteContent" ) {
+        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.`);
         }
-        else if (userDataSyncError.code === "ServiceChanged"  || userDataSyncError.code === "DefaultServiceChanged" ) {
-            if (isWeb && userDataSyncError.code === "DefaultServiceChanged"  && !this.hasProductQualityChanged()) {
+        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.');
             }
@@ -248,7 +250,7 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
         this._onError.fire(userDataSyncError);
     }
     async disableMachineEventually() {
-        this.storageService.store(disableMachineEventuallyKey, true, -1 , 1 );
+        this.storageService.store(disableMachineEventuallyKey, true, StorageScope.APPLICATION, StorageTarget.MACHINE);
         await timeout(1000 * 60 * 10);
         if (!this.hasToDisableMachineEventually()) {
             return;
@@ -259,10 +261,10 @@ let UserDataAutoSyncService = class UserDataAutoSyncService extends Disposable {
         }
     }
     hasToDisableMachineEventually() {
-        return this.storageService.getBoolean(disableMachineEventuallyKey, -1 , false);
+        return this.storageService.getBoolean(disableMachineEventuallyKey, StorageScope.APPLICATION, false);
     }
     stopDisableMachineEventually() {
-        this.storageService.remove(disableMachineEventuallyKey, -1 );
+        this.storageService.remove(disableMachineEventuallyKey, StorageScope.APPLICATION);
     }
     async triggerSync(sources, skipIfSyncedRecently, disableCache) {
         if (this.autoSync.value === undefined) {
@@ -381,7 +383,7 @@ class AutoSync extends Disposable {
         catch (e) {
             this.logService.error(e);
             error = e;
-            if (UserDataSyncError.toUserDataSyncError(e).code === "MethodNotFound" ) {
+            if (UserDataSyncError.toUserDataSyncError(e).code === UserDataSyncErrorCode.MethodNotFound) {
                 try {
                     this.logService.info('Auto Sync: Client is making invalid requests. Cleaning up data...');
                     await this.userDataSyncService.cleanUpRemoteData();
@@ -406,46 +408,28 @@ class AutoSync extends Disposable {
         if (this.manifest === null && (await this.userDataSyncService.hasPreviouslySynced())) {
             if (this.hasSyncServiceChanged()) {
                 if (await this.hasDefaultServiceChanged()) {
-                    throw ( new UserDataAutoSyncError(
-                        localize(3496, "Cannot sync because default service has changed"),
-                        "DefaultServiceChanged"
-                    ));
+                    throw ( new UserDataAutoSyncError(( localize(2230, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 }
                 else {
-                    throw ( new UserDataAutoSyncError(
-                        localize(3497, "Cannot sync because sync service has changed"),
-                        "ServiceChanged"
-                    ));
+                    throw ( new UserDataAutoSyncError(( localize(2231, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             }
             else {
-                throw ( new UserDataAutoSyncError(
-                    localize(3498, "Cannot sync because syncing is turned off in the cloud"),
-                    "TurnedOff"
-                ));
+                throw ( new UserDataAutoSyncError(( localize(2232, "Cannot sync because syncing is turned off in the cloud")), UserDataSyncErrorCode.TurnedOff));
             }
         }
-        const sessionId = this.storageService.get(sessionIdKey, -1 );
+        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(3496, "Cannot sync because default service has changed"),
-                        "DefaultServiceChanged"
-                    ));
+                    throw ( new UserDataAutoSyncError(( localize(2230, "Cannot sync because default service has changed")), UserDataSyncErrorCode.DefaultServiceChanged));
                 }
                 else {
-                    throw ( new UserDataAutoSyncError(
-                        localize(3497, "Cannot sync because sync service has changed"),
-                        "ServiceChanged"
-                    ));
+                    throw ( new UserDataAutoSyncError(( localize(2231, "Cannot sync because sync service has changed")), UserDataSyncErrorCode.ServiceChanged));
                 }
             }
             else {
-                throw ( new UserDataAutoSyncError(
-                    localize(3499, "Cannot sync because current session is expired"),
-                    "SessionExpired"
-                ));
+                throw ( new UserDataAutoSyncError(( localize(2233, "Cannot sync because current session is expired")), UserDataSyncErrorCode.SessionExpired));
             }
         }
         const machines = await this.userDataSyncMachinesService.getMachines(this.manifest || undefined);
@@ -454,10 +438,10 @@ class AutoSync extends Disposable {
         }
         const currentMachine = machines.find(machine => machine.isCurrent);
         if (currentMachine?.disabled) {
-            throw ( new UserDataAutoSyncError(localize(
-                3500,
+            throw ( new UserDataAutoSyncError(( localize(
+                2234,
                 "Cannot sync because syncing is turned off on this machine from another machine."
-            ), "TurnedOff" ));
+            )), UserDataSyncErrorCode.TurnedOff));
         }
         const startTime = ( new Date()).getTime();
         await this.syncTask.run();
@@ -469,12 +453,12 @@ class AutoSync extends Disposable {
             catch (error) {
                 throw ( new UserDataAutoSyncError(
                     toErrorMessage(error),
-                    error instanceof UserDataSyncError ? error.code : "Unknown"
+                    error instanceof UserDataSyncError ? error.code : UserDataSyncErrorCode.Unknown
                 ));
             }
         }
         if (this.manifest && this.manifest.session !== sessionId) {
-            this.storageService.store(sessionIdKey, this.manifest.session, -1 , 1 );
+            this.storageService.store(sessionIdKey, this.manifest.session, StorageScope.APPLICATION, StorageTarget.MACHINE);
         }
         if (token.isCancellationRequested) {
             return;

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

@@ -0,0 +1,17 @@
+import { IUserDataProfile } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { ISyncUserDataProfile } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync";
+interface IRelaxedMergeResult {
+    local: {
+        added: ISyncUserDataProfile[];
+        removed: IUserDataProfile[];
+        updated: ISyncUserDataProfile[];
+    };
+    remote: {
+        added: IUserDataProfile[];
+        removed: ISyncUserDataProfile[];
+        updated: IUserDataProfile[];
+    } | null;
+}
+export type IMergeResult = Required<IRelaxedMergeResult>;
+export declare function merge(local: IUserDataProfile[], remote: ISyncUserDataProfile[] | null, lastSync: ISyncUserDataProfile[] | null, ignored: string[]): IMergeResult;
+export {};

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

@@ -1,3 +1,4 @@
+
 import { equals } from 'vscode/vscode/vs/base/common/objects';
 
 function merge(local, remote, lastSync, ignored) {

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

@@ -0,0 +1,62 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IUserDataProfile } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { IUserDataProfilesService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+import { AbstractSynchroniser, IAcceptResult, IMergeResult, IResourcePreview } from "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/userDataSync/common/abstractSynchronizer";
+import { IRemoteUserData, IUserDataSynchroniser, ISyncUserDataProfile, ISyncData, IUserDataResourceManifest } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync";
+import { IUserDataSyncLogService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncEnablementService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncLocalStoreService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncStoreService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+interface IUserDataProfileManifestResourceMergeResult extends IAcceptResult {
+    readonly local: {
+        added: ISyncUserDataProfile[];
+        removed: IUserDataProfile[];
+        updated: ISyncUserDataProfile[];
+    };
+    readonly remote: {
+        added: IUserDataProfile[];
+        removed: ISyncUserDataProfile[];
+        updated: IUserDataProfile[];
+    } | null;
+}
+interface IUserDataProfilesManifestResourcePreview extends IResourcePreview {
+    readonly previewResult: IUserDataProfileManifestResourceMergeResult;
+    readonly remoteProfiles: ISyncUserDataProfile[] | null;
+}
+export declare class UserDataProfilesManifestSynchroniser extends AbstractSynchroniser implements IUserDataSynchroniser {
+    private readonly userDataProfilesService;
+    protected readonly version: number;
+    readonly previewResource: URI;
+    readonly baseResource: URI;
+    readonly localResource: URI;
+    readonly remoteResource: URI;
+    readonly acceptedResource: URI;
+    constructor(profile: IUserDataProfile, collection: string | undefined, userDataProfilesService: IUserDataProfilesService, fileService: IFileService, environmentService: IEnvironmentService, storageService: IStorageService, userDataSyncStoreService: IUserDataSyncStoreService, userDataSyncLocalStoreService: IUserDataSyncLocalStoreService, logService: IUserDataSyncLogService, configurationService: IConfigurationService, userDataSyncEnablementService: IUserDataSyncEnablementService, telemetryService: ITelemetryService, uriIdentityService: IUriIdentityService);
+    getLastSyncedProfiles(): Promise<ISyncUserDataProfile[] | null>;
+    getRemoteSyncedProfiles(manifest: IUserDataResourceManifest | null): Promise<ISyncUserDataProfile[] | null>;
+    protected generateSyncPreview(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, isRemoteDataFromCurrentMachine: boolean): Promise<IUserDataProfilesManifestResourcePreview[]>;
+    protected hasRemoteChanged(lastSyncUserData: IRemoteUserData): Promise<boolean>;
+    protected getMergeResult(resourcePreview: IUserDataProfilesManifestResourcePreview, token: CancellationToken): Promise<IMergeResult>;
+    protected getAcceptResult(resourcePreview: IUserDataProfilesManifestResourcePreview, resource: URI, content: string | null | undefined, token: CancellationToken): Promise<IAcceptResult>;
+    private acceptLocal;
+    private acceptRemote;
+    protected applyResult(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, resourcePreviews: [
+        IUserDataProfilesManifestResourcePreview,
+        IUserDataProfileManifestResourceMergeResult
+    ][], force: boolean): Promise<void>;
+    updateRemoteProfiles(profiles: ISyncUserDataProfile[], ref: string | null): Promise<IRemoteUserData>;
+    hasLocalData(): Promise<boolean>;
+    resolveContent(uri: URI): Promise<string | null>;
+    private getLocalUserDataProfiles;
+    private stringifyRemoteProfiles;
+}
+export declare function stringifyLocalProfiles(profiles: IUserDataProfile[], format: boolean): string;
+export declare function parseUserDataProfilesManifest(syncData: ISyncData): ISyncUserDataProfile[];
+export {};

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

@@ -1,5 +1,6 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { toFormattedString } from 'vscode/vscode/vs/base/common/jsonFormatter';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { toFormattedString } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/base/common/jsonFormatter';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
@@ -7,14 +8,14 @@ import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storag
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
-import { AbstractSynchroniser } from 'vscode/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
+import { AbstractSynchroniser } from '@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
 import { merge } from './userDataProfilesManifestMerge.js';
-import { USER_DATA_SYNC_SCHEME, UserDataSyncError } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { SyncResource, USER_DATA_SYNC_SCHEME, Change, UserDataSyncError, UserDataSyncErrorCode } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncLogService, IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 
 let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchroniser extends AbstractSynchroniser {
     constructor(profile, collection, userDataProfilesService, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, logService, configurationService, userDataSyncEnablementService, telemetryService, uriIdentityService) {
-        super({ syncResource: "profiles" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
+        super({ syncResource: SyncResource.Profiles, profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
         this.userDataProfilesService = userDataProfilesService;
         this.version = 2;
         this.previewResource = this.extUri.joinPath(this.syncPreviewFolder, 'profiles.json');
@@ -41,8 +42,8 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
         const previewResult = {
             local, remote,
             content: lastSyncProfiles ? this.stringifyRemoteProfiles(lastSyncProfiles) : null,
-            localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? 2  : 0 ,
-            remoteChange: remote !== null ? 2  : 0 ,
+            localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? Change.Modified : Change.None,
+            remoteChange: remote !== null ? Change.Modified : Change.None,
         };
         const localContent = stringifyLocalProfiles(localProfiles, false);
         return [{
@@ -89,8 +90,8 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
             content: resourcePreview.localContent,
             local,
             remote,
-            localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? 2  : 0 ,
-            remoteChange: remote !== null ? 2  : 0 ,
+            localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? Change.Modified : Change.None,
+            remoteChange: remote !== null ? Change.Modified : Change.None,
         };
     }
     async acceptRemote(resourcePreview) {
@@ -111,8 +112,8 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
                 content: resourcePreview.remoteContent,
                 local,
                 remote,
-                localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? 2  : 0 ,
-                remoteChange: remote !== null ? 2  : 0 ,
+                localChange: local.added.length > 0 || local.removed.length > 0 || local.updated.length > 0 ? Change.Modified : Change.None,
+                remoteChange: remote !== null ? Change.Modified : Change.None,
             };
         }
         else {
@@ -120,24 +121,24 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
                 content: resourcePreview.remoteContent,
                 local: { added: [], removed: [], updated: [] },
                 remote: null,
-                localChange: 0 ,
-                remoteChange: 0 ,
+                localChange: Change.None,
+                remoteChange: Change.None,
             };
         }
     }
     async applyResult(remoteUserData, lastSyncUserData, resourcePreviews, force) {
         const { local, remote, localChange, remoteChange } = resourcePreviews[0][1];
-        if (localChange === 0  && remoteChange === 0 ) {
+        if (localChange === Change.None && remoteChange === Change.None) {
             this.logService.info(`${this.syncResourceLogLabel}: No changes found during synchronizing profiles.`);
         }
         const remoteProfiles = resourcePreviews[0][0].remoteProfiles || [];
         if (remoteProfiles.length + (remote?.added.length ?? 0) - (remote?.removed.length ?? 0) > 20) {
             throw ( new UserDataSyncError(
                 'Too many profiles to sync. Please remove some profiles and try again.',
-                "LocalTooManyProfiles"
+                UserDataSyncErrorCode.LocalTooManyProfiles
             ));
         }
-        if (localChange !== 0 ) {
+        if (localChange !== Change.None) {
             await this.backupLocal(stringifyLocalProfiles(this.getLocalUserDataProfiles(), false));
             await Promise.all(( local.removed.map(async (profile) => {
                 this.logService.trace(`${this.syncResourceLogLabel}: Removing '${profile.name}' profile...`);
@@ -161,7 +162,7 @@ let UserDataProfilesManifestSynchroniser = class UserDataProfilesManifestSynchro
                 }
             })));
         }
-        if (remoteChange !== 0 ) {
+        if (remoteChange !== Change.None) {
             this.logService.trace(`${this.syncResourceLogLabel}: Updating remote profiles...`);
             const addedCollections = [];
             const canAddRemoteProfiles = remoteProfiles.length + (remote?.added.length ?? 0) <= 20;

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

@@ -0,0 +1,23 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IUserDataSyncLogService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncStoreService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { IUserDataSyncAccountService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service";
+export interface IUserDataSyncAccount {
+    readonly authenticationProviderId: string;
+    readonly token: string;
+}
+export declare class UserDataSyncAccountService extends Disposable implements IUserDataSyncAccountService {
+    private readonly userDataSyncStoreService;
+    private readonly logService;
+    _serviceBrand: any;
+    private _account;
+    get account(): IUserDataSyncAccount | undefined;
+    private _onDidChangeAccount;
+    readonly onDidChangeAccount: Event<IUserDataSyncAccount | undefined>;
+    private _onTokenFailed;
+    readonly onTokenFailed: Event<boolean>;
+    private wasTokenFailed;
+    constructor(userDataSyncStoreService: IUserDataSyncStoreService, logService: IUserDataSyncLogService);
+    updateAccount(account: IUserDataSyncAccount | undefined): Promise<void>;
+}

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

@@ -1,6 +1,8 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { UserDataSyncErrorCode } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreService, IUserDataSyncLogService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 
 let UserDataSyncAccountService = class UserDataSyncAccountService extends Disposable {
@@ -17,7 +19,7 @@ let UserDataSyncAccountService = class UserDataSyncAccountService extends Dispos
         this._register(userDataSyncStoreService.onTokenFailed(code => {
             this.logService.info('Settings Sync auth token failed', this.account?.authenticationProviderId, this.wasTokenFailed, code);
             this.updateAccount(undefined);
-            if (code === "Forbidden" ) {
+            if (code === UserDataSyncErrorCode.Forbidden) {
                 this._onTokenFailed.fire(true );
             }
             else {