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

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

@@ -0,0 +1,245 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+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 { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { AbstractFileSynchroniser, AbstractInitializer } from 'vscode/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
+import { USER_DATA_SYNC_SCHEME } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncLogService, IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+
+function getTasksContentFromSyncContent(syncContent, logService) {
+    try {
+        const parsed = JSON.parse(syncContent);
+        return parsed.tasks ?? null;
+    }
+    catch (e) {
+        logService.error(e);
+        return null;
+    }
+}
+let TasksSynchroniser = class TasksSynchroniser extends AbstractFileSynchroniser {
+    constructor(profile, collection, userDataSyncStoreService, userDataSyncLocalStoreService, logService, configurationService, userDataSyncEnablementService, fileService, environmentService, storageService, telemetryService, uriIdentityService) {
+        super(profile.tasksResource, { syncResource: "tasks" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
+        this.version = 1;
+        this.previewResource = this.extUri.joinPath(this.syncPreviewFolder, 'tasks.json');
+        this.baseResource = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' });
+        this.localResource = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' });
+        this.remoteResource = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' });
+        this.acceptedResource = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' });
+    }
+    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine, userDataSyncConfiguration) {
+        const remoteContent = remoteUserData.syncData ? getTasksContentFromSyncContent(remoteUserData.syncData.content, this.logService) : null;
+        lastSyncUserData = lastSyncUserData === null && isRemoteDataFromCurrentMachine ? remoteUserData : lastSyncUserData;
+        const lastSyncContent = lastSyncUserData?.syncData ? getTasksContentFromSyncContent(lastSyncUserData.syncData.content, this.logService) : null;
+        const fileContent = await this.getLocalFileContent();
+        let content = null;
+        let hasLocalChanged = false;
+        let hasRemoteChanged = false;
+        let hasConflicts = false;
+        if (remoteUserData.syncData) {
+            const localContent = fileContent ? ( fileContent.value.toString()) : null;
+            if (!lastSyncContent
+                || lastSyncContent !== localContent
+                || lastSyncContent !== remoteContent
+            ) {
+                this.logService.trace(`${this.syncResourceLogLabel}: Merging remote tasks with local tasks...`);
+                const result = merge(localContent, remoteContent, lastSyncContent);
+                content = result.content;
+                hasConflicts = result.hasConflicts;
+                hasLocalChanged = result.hasLocalChanged;
+                hasRemoteChanged = result.hasRemoteChanged;
+            }
+        }
+        else if (fileContent) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Remote tasks does not exist. Synchronizing tasks for the first time.`);
+            content = ( fileContent.value.toString());
+            hasRemoteChanged = true;
+        }
+        const previewResult = {
+            content: hasConflicts ? lastSyncContent : content,
+            localChange: hasLocalChanged ? fileContent ? 2  : 1  : 0 ,
+            remoteChange: hasRemoteChanged ? 2  : 0 ,
+            hasConflicts
+        };
+        const localContent = fileContent ? ( fileContent.value.toString()) : null;
+        return [{
+                fileContent,
+                baseResource: this.baseResource,
+                baseContent: lastSyncContent,
+                localResource: this.localResource,
+                localContent,
+                localChange: previewResult.localChange,
+                remoteResource: this.remoteResource,
+                remoteContent,
+                remoteChange: previewResult.remoteChange,
+                previewResource: this.previewResource,
+                previewResult,
+                acceptedResource: this.acceptedResource,
+            }];
+    }
+    async hasRemoteChanged(lastSyncUserData) {
+        const lastSyncContent = lastSyncUserData?.syncData ? getTasksContentFromSyncContent(lastSyncUserData.syncData.content, this.logService) : null;
+        if (lastSyncContent === null) {
+            return true;
+        }
+        const fileContent = await this.getLocalFileContent();
+        const localContent = fileContent ? ( fileContent.value.toString()) : null;
+        const result = merge(localContent, lastSyncContent, lastSyncContent);
+        return result.hasLocalChanged || result.hasRemoteChanged;
+    }
+    async getMergeResult(resourcePreview, token) {
+        return resourcePreview.previewResult;
+    }
+    async getAcceptResult(resourcePreview, resource, content, token) {
+        if (this.extUri.isEqual(resource, this.localResource)) {
+            return {
+                content: resourcePreview.fileContent ? ( resourcePreview.fileContent.value.toString()) : null,
+                localChange: 0 ,
+                remoteChange: 2 ,
+            };
+        }
+        if (this.extUri.isEqual(resource, this.remoteResource)) {
+            return {
+                content: resourcePreview.remoteContent,
+                localChange: 2 ,
+                remoteChange: 0 ,
+            };
+        }
+        if (this.extUri.isEqual(resource, this.previewResource)) {
+            if (content === undefined) {
+                return {
+                    content: resourcePreview.previewResult.content,
+                    localChange: resourcePreview.previewResult.localChange,
+                    remoteChange: resourcePreview.previewResult.remoteChange,
+                };
+            }
+            else {
+                return {
+                    content,
+                    localChange: 2 ,
+                    remoteChange: 2 ,
+                };
+            }
+        }
+        throw ( new Error(`Invalid Resource: ${( resource.toString())}`));
+    }
+    async applyResult(remoteUserData, lastSyncUserData, resourcePreviews, force) {
+        const { fileContent } = resourcePreviews[0][0];
+        const { content, localChange, remoteChange } = resourcePreviews[0][1];
+        if (localChange === 0  && remoteChange === 0 ) {
+            this.logService.info(`${this.syncResourceLogLabel}: No changes found during synchronizing tasks.`);
+        }
+        if (localChange !== 0 ) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating local tasks...`);
+            if (fileContent) {
+                await this.backupLocal(JSON.stringify(this.toTasksSyncContent(( fileContent.value.toString()))));
+            }
+            if (content) {
+                await this.updateLocalFileContent(content, fileContent, force);
+            }
+            else {
+                await this.deleteLocalFile();
+            }
+            this.logService.info(`${this.syncResourceLogLabel}: Updated local tasks`);
+        }
+        if (remoteChange !== 0 ) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating remote tasks...`);
+            const remoteContents = JSON.stringify(this.toTasksSyncContent(content));
+            remoteUserData = await this.updateRemoteUserData(remoteContents, force ? null : remoteUserData.ref);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated remote tasks`);
+        }
+        try {
+            await this.fileService.del(this.previewResource);
+        }
+        catch (e) {  }
+        if (lastSyncUserData?.ref !== remoteUserData.ref) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating last synchronized tasks...`);
+            await this.updateLastSyncUserData(remoteUserData);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated last synchronized tasks`);
+        }
+    }
+    async hasLocalData() {
+        return this.fileService.exists(this.file);
+    }
+    async resolveContent(uri) {
+        if (this.extUri.isEqual(this.remoteResource, uri)
+            || this.extUri.isEqual(this.baseResource, uri)
+            || this.extUri.isEqual(this.localResource, uri)
+            || this.extUri.isEqual(this.acceptedResource, uri)) {
+            return this.resolvePreviewContent(uri);
+        }
+        return null;
+    }
+    toTasksSyncContent(tasks) {
+        return tasks ? { tasks } : {};
+    }
+};
+TasksSynchroniser = ( __decorate([
+    ( __param(2, IUserDataSyncStoreService)),
+    ( __param(3, IUserDataSyncLocalStoreService)),
+    ( __param(4, IUserDataSyncLogService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IUserDataSyncEnablementService)),
+    ( __param(7, IFileService)),
+    ( __param(8, IEnvironmentService)),
+    ( __param(9, IStorageService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IUriIdentityService))
+], TasksSynchroniser));
+let TasksInitializer = class TasksInitializer extends AbstractInitializer {
+    constructor(fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService) {
+        super("tasks" , userDataProfilesService, environmentService, logService, fileService, storageService, uriIdentityService);
+        this.tasksResource = this.userDataProfilesService.defaultProfile.tasksResource;
+    }
+    async doInitialize(remoteUserData) {
+        const tasksContent = remoteUserData.syncData ? getTasksContentFromSyncContent(remoteUserData.syncData.content, this.logService) : null;
+        if (!tasksContent) {
+            this.logService.info('Skipping initializing tasks because remote tasks does not exist.');
+            return;
+        }
+        const isEmpty = await this.isEmpty();
+        if (!isEmpty) {
+            this.logService.info('Skipping initializing tasks because local tasks exist.');
+            return;
+        }
+        await this.fileService.writeFile(this.tasksResource, VSBuffer.fromString(tasksContent));
+        await this.updateLastSyncUserData(remoteUserData);
+    }
+    async isEmpty() {
+        return this.fileService.exists(this.tasksResource);
+    }
+};
+TasksInitializer = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, IUserDataSyncLogService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IUriIdentityService))
+], TasksInitializer));
+function merge(originalLocalContent, originalRemoteContent, baseContent) {
+    if (originalLocalContent === null && originalRemoteContent === null && baseContent === null) {
+        return { content: null, hasLocalChanged: false, hasRemoteChanged: false, hasConflicts: false };
+    }
+    if (originalLocalContent === originalRemoteContent) {
+        return { content: null, hasLocalChanged: false, hasRemoteChanged: false, hasConflicts: false };
+    }
+    const localForwarded = baseContent !== originalLocalContent;
+    const remoteForwarded = baseContent !== originalRemoteContent;
+    if (!localForwarded && !remoteForwarded) {
+        return { content: null, hasLocalChanged: false, hasRemoteChanged: false, hasConflicts: false };
+    }
+    if (localForwarded && !remoteForwarded) {
+        return { content: originalLocalContent, hasRemoteChanged: true, hasLocalChanged: false, hasConflicts: false };
+    }
+    if (remoteForwarded && !localForwarded) {
+        return { content: originalRemoteContent, hasLocalChanged: true, hasRemoteChanged: false, hasConflicts: false };
+    }
+    return { content: originalLocalContent, hasLocalChanged: true, hasRemoteChanged: true, hasConflicts: true };
+}
+
+export { TasksInitializer, TasksSynchroniser, getTasksContentFromSyncContent };

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

@@ -0,0 +1,9 @@
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { UserDataProfilesWorkbenchContribution } from './userDataProfile.js';
+import './userDataProfileActions.js';
+import { UserDataProfilePreviewContribution } from './userDataProfilePreview.js';
+
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+registerWorkbenchContribution2(UserDataProfilesWorkbenchContribution.ID, UserDataProfilesWorkbenchContribution, 2 );
+workbenchRegistry.registerWorkbenchContribution(UserDataProfilePreviewContribution, 3 );