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

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

@@ -0,0 +1,322 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { ConfigurationModelParser } from 'vscode/vscode/vs/platform/configuration/common/configurationModels';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.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 { AbstractJsonFileSynchroniser, AbstractInitializer } from 'vscode/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
+import { merge, updateIgnoredSettings, isEmpty, getIgnoredSettings } from 'vscode/vscode/vs/platform/userDataSync/common/settingsMerge';
+import { USER_DATA_SYNC_SCHEME, USER_DATA_SYNC_CONFIGURATION_SCOPE, UserDataSyncError } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncLogService, IUserDataSyncUtilService, IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+
+const _moduleId = "vs/platform/userDataSync/common/settingsSync";
+function isSettingsSyncContent(thing) {
+    return thing
+        && (thing.settings && typeof thing.settings === 'string')
+        && ( Object.keys(thing)).length === 1;
+}
+function parseSettingsSyncContent(syncContent) {
+    const parsed = JSON.parse(syncContent);
+    return isSettingsSyncContent(parsed) ? parsed :  { settings: syncContent };
+}
+let SettingsSynchroniser = class SettingsSynchroniser extends AbstractJsonFileSynchroniser {
+    constructor(profile, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, logService, userDataSyncUtilService, configurationService, userDataSyncEnablementService, telemetryService, extensionManagementService, uriIdentityService) {
+        super(profile.settingsResource, { syncResource: "settings" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, userDataSyncUtilService, configurationService, uriIdentityService);
+        this.extensionManagementService = extensionManagementService;
+        this.version = 2;
+        this.previewResource = this.extUri.joinPath(this.syncPreviewFolder, 'settings.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' });
+        this._defaultIgnoredSettings = undefined;
+    }
+    async getRemoteUserDataSyncConfiguration(manifest) {
+        const lastSyncUserData = await this.getLastSyncUserData();
+        const remoteUserData = await this.getLatestRemoteUserData(manifest, lastSyncUserData);
+        const remoteSettingsSyncContent = this.getSettingsSyncContent(remoteUserData);
+        const parser = ( new ConfigurationModelParser(USER_DATA_SYNC_CONFIGURATION_SCOPE, this.logService));
+        if (remoteSettingsSyncContent?.settings) {
+            parser.parse(remoteSettingsSyncContent.settings);
+        }
+        return parser.configurationModel.getValue(USER_DATA_SYNC_CONFIGURATION_SCOPE) || {};
+    }
+    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine) {
+        const fileContent = await this.getLocalFileContent();
+        const formattingOptions = await this.getFormattingOptions();
+        const remoteSettingsSyncContent = this.getSettingsSyncContent(remoteUserData);
+        lastSyncUserData = lastSyncUserData === null && isRemoteDataFromCurrentMachine ? remoteUserData : lastSyncUserData;
+        const lastSettingsSyncContent = lastSyncUserData ? this.getSettingsSyncContent(lastSyncUserData) : null;
+        const ignoredSettings = await this.getIgnoredSettings();
+        let mergedContent = null;
+        let hasLocalChanged = false;
+        let hasRemoteChanged = false;
+        let hasConflicts = false;
+        if (remoteSettingsSyncContent) {
+            let localContent = fileContent ? ( fileContent.value.toString()).trim() : '{}';
+            localContent = localContent || '{}';
+            this.validateContent(localContent);
+            this.logService.trace(`${this.syncResourceLogLabel}: Merging remote settings with local settings...`);
+            const result = merge(localContent, remoteSettingsSyncContent.settings, lastSettingsSyncContent ? lastSettingsSyncContent.settings : null, ignoredSettings, [], formattingOptions);
+            mergedContent = result.localContent || result.remoteContent;
+            hasLocalChanged = result.localContent !== null;
+            hasRemoteChanged = result.remoteContent !== null;
+            hasConflicts = result.hasConflicts;
+        }
+        else if (fileContent) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Remote settings does not exist. Synchronizing settings for the first time.`);
+            mergedContent = ( fileContent.value.toString()).trim() || '{}';
+            this.validateContent(mergedContent);
+            hasRemoteChanged = true;
+        }
+        const localContent = fileContent ? ( fileContent.value.toString()) : null;
+        const baseContent = lastSettingsSyncContent?.settings ?? null;
+        const previewResult = {
+            content: hasConflicts ? baseContent : mergedContent,
+            localChange: hasLocalChanged ? 2  : 0 ,
+            remoteChange: hasRemoteChanged ? 2  : 0 ,
+            hasConflicts
+        };
+        return [{
+                fileContent,
+                baseResource: this.baseResource,
+                baseContent,
+                localResource: this.localResource,
+                localContent,
+                localChange: previewResult.localChange,
+                remoteResource: this.remoteResource,
+                remoteContent: remoteSettingsSyncContent ? remoteSettingsSyncContent.settings : null,
+                remoteChange: previewResult.remoteChange,
+                previewResource: this.previewResource,
+                previewResult,
+                acceptedResource: this.acceptedResource,
+            }];
+    }
+    async hasRemoteChanged(lastSyncUserData) {
+        const lastSettingsSyncContent = this.getSettingsSyncContent(lastSyncUserData);
+        if (lastSettingsSyncContent === null) {
+            return true;
+        }
+        const fileContent = await this.getLocalFileContent();
+        const localContent = fileContent ? ( fileContent.value.toString()).trim() : '';
+        const ignoredSettings = await this.getIgnoredSettings();
+        const formattingOptions = await this.getFormattingOptions();
+        const result = merge(localContent || '{}', lastSettingsSyncContent.settings, lastSettingsSyncContent.settings, ignoredSettings, [], formattingOptions);
+        return result.remoteContent !== null;
+    }
+    async getMergeResult(resourcePreview, token) {
+        const formatUtils = await this.getFormattingOptions();
+        const ignoredSettings = await this.getIgnoredSettings();
+        return {
+            ...resourcePreview.previewResult,
+            content: resourcePreview.previewResult.content ? updateIgnoredSettings(resourcePreview.previewResult.content, '{}', ignoredSettings, formatUtils) : null
+        };
+    }
+    async getAcceptResult(resourcePreview, resource, content, token) {
+        const formattingOptions = await this.getFormattingOptions();
+        const ignoredSettings = await this.getIgnoredSettings();
+        if (this.extUri.isEqual(resource, this.localResource)) {
+            return {
+                content: resourcePreview.fileContent ? updateIgnoredSettings(( resourcePreview.fileContent.value.toString()), '{}', ignoredSettings, formattingOptions) : null,
+                localChange: 0 ,
+                remoteChange: 2 ,
+            };
+        }
+        if (this.extUri.isEqual(resource, this.remoteResource)) {
+            return {
+                content: resourcePreview.remoteContent !== null ? updateIgnoredSettings(resourcePreview.remoteContent, resourcePreview.fileContent ? ( resourcePreview.fileContent.value.toString()) : '{}', ignoredSettings, formattingOptions) : null,
+                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: content !== null ? updateIgnoredSettings(content, resourcePreview.fileContent ? ( resourcePreview.fileContent.value.toString()) : '{}', ignoredSettings, formattingOptions) : null,
+                    localChange: 2 ,
+                    remoteChange: 2 ,
+                };
+            }
+        }
+        throw ( new Error(`Invalid Resource: ${( resource.toString())}`));
+    }
+    async applyResult(remoteUserData, lastSyncUserData, resourcePreviews, force) {
+        const { fileContent } = resourcePreviews[0][0];
+        let { content, localChange, remoteChange } = resourcePreviews[0][1];
+        if (localChange === 0  && remoteChange === 0 ) {
+            this.logService.info(`${this.syncResourceLogLabel}: No changes found during synchronizing settings.`);
+        }
+        content = content ? content.trim() : '{}';
+        content = content || '{}';
+        this.validateContent(content);
+        if (localChange !== 0 ) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating local settings...`);
+            if (fileContent) {
+                await this.backupLocal(JSON.stringify(this.toSettingsSyncContent(( fileContent.value.toString()))));
+            }
+            await this.updateLocalFileContent(content, fileContent, force);
+            await this.configurationService.reloadConfiguration(3 );
+            this.logService.info(`${this.syncResourceLogLabel}: Updated local settings`);
+        }
+        if (remoteChange !== 0 ) {
+            const formatUtils = await this.getFormattingOptions();
+            const remoteSettingsSyncContent = this.getSettingsSyncContent(remoteUserData);
+            const ignoredSettings = await this.getIgnoredSettings(content);
+            content = updateIgnoredSettings(content, remoteSettingsSyncContent ? remoteSettingsSyncContent.settings : '{}', ignoredSettings, formatUtils);
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating remote settings...`);
+            remoteUserData = await this.updateRemoteUserData(JSON.stringify(this.toSettingsSyncContent(content)), force ? null : remoteUserData.ref);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated remote settings`);
+        }
+        try {
+            await this.fileService.del(this.previewResource);
+        }
+        catch (e) {  }
+        if (lastSyncUserData?.ref !== remoteUserData.ref) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating last synchronized settings...`);
+            await this.updateLastSyncUserData(remoteUserData);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated last synchronized settings`);
+        }
+    }
+    async hasLocalData() {
+        try {
+            const localFileContent = await this.getLocalFileContent();
+            if (localFileContent) {
+                return !isEmpty(( localFileContent.value.toString()));
+            }
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async resolveContent(uri) {
+        if (this.extUri.isEqual(this.remoteResource, uri)
+            || this.extUri.isEqual(this.localResource, uri)
+            || this.extUri.isEqual(this.acceptedResource, uri)
+            || this.extUri.isEqual(this.baseResource, uri)) {
+            return this.resolvePreviewContent(uri);
+        }
+        return null;
+    }
+    async resolvePreviewContent(resource) {
+        let content = await super.resolvePreviewContent(resource);
+        if (content) {
+            const formatUtils = await this.getFormattingOptions();
+            const ignoredSettings = await this.getIgnoredSettings();
+            content = updateIgnoredSettings(content, '{}', ignoredSettings, formatUtils);
+        }
+        return content;
+    }
+    getSettingsSyncContent(remoteUserData) {
+        return remoteUserData.syncData ? this.parseSettingsSyncContent(remoteUserData.syncData.content) : null;
+    }
+    parseSettingsSyncContent(syncContent) {
+        try {
+            return parseSettingsSyncContent(syncContent);
+        }
+        catch (e) {
+            this.logService.error(e);
+        }
+        return null;
+    }
+    toSettingsSyncContent(settings) {
+        return { settings };
+    }
+    async getIgnoredSettings(content) {
+        if (!this._defaultIgnoredSettings) {
+            this._defaultIgnoredSettings = this.userDataSyncUtilService.resolveDefaultIgnoredSettings();
+            const disposable = this._register(Event.any(Event.filter(this.extensionManagementService.onDidInstallExtensions, (e => ( e.some(({ local }) => !!local)))), Event.filter(this.extensionManagementService.onDidUninstallExtension, (e => !e.error)))(() => {
+                disposable.dispose();
+                this._defaultIgnoredSettings = undefined;
+            }));
+        }
+        const defaultIgnoredSettings = await this._defaultIgnoredSettings;
+        return getIgnoredSettings(defaultIgnoredSettings, this.configurationService, content);
+    }
+    validateContent(content) {
+        if (this.hasErrors(content, false)) {
+            throw ( new UserDataSyncError(localizeWithPath(
+                _moduleId,
+                0,
+                "Unable to sync settings as there are errors/warning in settings file."
+            ), "LocalInvalidContent" , this.resource));
+        }
+    }
+};
+SettingsSynchroniser = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IUserDataSyncStoreService)),
+    ( __param(6, IUserDataSyncLocalStoreService)),
+    ( __param(7, IUserDataSyncLogService)),
+    ( __param(8, IUserDataSyncUtilService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IUserDataSyncEnablementService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IExtensionManagementService)),
+    ( __param(13, IUriIdentityService))
+], SettingsSynchroniser));
+let SettingsInitializer = class SettingsInitializer extends AbstractInitializer {
+    constructor(fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService) {
+        super("settings" , userDataProfilesService, environmentService, logService, fileService, storageService, uriIdentityService);
+    }
+    async doInitialize(remoteUserData) {
+        const settingsSyncContent = remoteUserData.syncData ? this.parseSettingsSyncContent(remoteUserData.syncData.content) : null;
+        if (!settingsSyncContent) {
+            this.logService.info('Skipping initializing settings because remote settings does not exist.');
+            return;
+        }
+        const isEmpty = await this.isEmpty();
+        if (!isEmpty) {
+            this.logService.info('Skipping initializing settings because local settings exist.');
+            return;
+        }
+        await this.fileService.writeFile(this.userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(settingsSyncContent.settings));
+        await this.updateLastSyncUserData(remoteUserData);
+    }
+    async isEmpty() {
+        try {
+            const fileContent = await this.fileService.readFile(this.userDataProfilesService.defaultProfile.settingsResource);
+            return isEmpty(( fileContent.value.toString()).trim());
+        }
+        catch (error) {
+            return error.fileOperationResult === 1 ;
+        }
+    }
+    parseSettingsSyncContent(syncContent) {
+        try {
+            return parseSettingsSyncContent(syncContent);
+        }
+        catch (e) {
+            this.logService.error(e);
+        }
+        return null;
+    }
+};
+SettingsInitializer = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, IUserDataSyncLogService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IUriIdentityService))
+], SettingsInitializer));
+
+export { SettingsInitializer, SettingsSynchroniser, parseSettingsSyncContent };

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

@@ -0,0 +1,126 @@
+function merge(local, remote, base) {
+    const localAdded = {};
+    const localUpdated = {};
+    const localRemoved = ( new Set());
+    if (!remote) {
+        return {
+            local: { added: localAdded, updated: localUpdated, removed: [...( localRemoved.values())] },
+            remote: { added: local, updated: {}, removed: [] },
+            conflicts: []
+        };
+    }
+    const localToRemote = compare(local, remote);
+    if (localToRemote.added.size === 0 && localToRemote.removed.size === 0 && localToRemote.updated.size === 0) {
+        return {
+            local: { added: localAdded, updated: localUpdated, removed: [...( localRemoved.values())] },
+            remote: { added: {}, updated: {}, removed: [] },
+            conflicts: []
+        };
+    }
+    const baseToLocal = compare(base, local);
+    const baseToRemote = compare(base, remote);
+    const remoteAdded = {};
+    const remoteUpdated = {};
+    const remoteRemoved = ( new Set());
+    const conflicts = ( new Set());
+    for (const key of ( baseToLocal.removed.values())) {
+        if (( baseToRemote.updated.has(key))) {
+            localAdded[key] = remote[key];
+        }
+        else {
+            remoteRemoved.add(key);
+        }
+    }
+    for (const key of ( baseToRemote.removed.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToLocal.updated.has(key))) {
+            conflicts.add(key);
+        }
+        else {
+            localRemoved.add(key);
+        }
+    }
+    for (const key of ( baseToLocal.updated.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToRemote.updated.has(key))) {
+            if (( localToRemote.updated.has(key))) {
+                conflicts.add(key);
+            }
+        }
+        else {
+            remoteUpdated[key] = local[key];
+        }
+    }
+    for (const key of ( baseToRemote.updated.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToLocal.updated.has(key))) {
+            if (( localToRemote.updated.has(key))) {
+                conflicts.add(key);
+            }
+        }
+        else if (local[key] !== undefined) {
+            localUpdated[key] = remote[key];
+        }
+    }
+    for (const key of ( baseToLocal.added.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToRemote.added.has(key))) {
+            if (( localToRemote.updated.has(key))) {
+                conflicts.add(key);
+            }
+        }
+        else {
+            remoteAdded[key] = local[key];
+        }
+    }
+    for (const key of ( baseToRemote.added.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToLocal.added.has(key))) {
+            if (( localToRemote.updated.has(key))) {
+                conflicts.add(key);
+            }
+        }
+        else {
+            localAdded[key] = remote[key];
+        }
+    }
+    return {
+        local: { added: localAdded, removed: [...( localRemoved.values())], updated: localUpdated },
+        remote: { added: remoteAdded, removed: [...( remoteRemoved.values())], updated: remoteUpdated },
+        conflicts: [...( conflicts.values())],
+    };
+}
+function compare(from, to) {
+    const fromKeys = from ? ( Object.keys(from)) : [];
+    const toKeys = to ? ( Object.keys(to)) : [];
+    const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const updated = ( new Set());
+    for (const key of fromKeys) {
+        if (( removed.has(key))) {
+            continue;
+        }
+        const fromSnippet = from[key];
+        const toSnippet = to[key];
+        if (fromSnippet !== toSnippet) {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated };
+}
+function areSame(a, b) {
+    const { added, removed, updated } = compare(a, b);
+    return added.size === 0 && removed.size === 0 && updated.size === 0;
+}
+
+export { areSame, merge };