@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,275 @@
+import { equals } from '../../../base/common/arrays.js';
+import { parse } from '../../../base/common/json.js';
+import { equals as equals$1 } from '../../../base/common/objects.js';
+import { ContextKeyExpr } from '../../contextkey/common/contextkey.js';
+import { edit } from './content.js';
+function parseKeybindings(content) {
+    return parse(content) || [];
+}
+async function merge(localContent, remoteContent, baseContent, formattingOptions, userDataSyncUtilService) {
+    const local = parseKeybindings(localContent);
+    const remote = parseKeybindings(remoteContent);
+    const base = baseContent ? parseKeybindings(baseContent) : null;
+    const userbindings = ( [...local, ...remote, ...(base || [])].map(keybinding => keybinding.key));
+    const normalizedKeys = await userDataSyncUtilService.resolveUserBindings(userbindings);
+    const keybindingsMergeResult = computeMergeResultByKeybinding(local, remote, base, normalizedKeys);
+    if (!keybindingsMergeResult.hasLocalForwarded && !keybindingsMergeResult.hasRemoteForwarded) {
+        return { mergeContent: localContent, hasChanges: false, hasConflicts: false };
+    }
+    if (!keybindingsMergeResult.hasLocalForwarded && keybindingsMergeResult.hasRemoteForwarded) {
+        return { mergeContent: remoteContent, hasChanges: true, hasConflicts: false };
+    }
+    if (keybindingsMergeResult.hasLocalForwarded && !keybindingsMergeResult.hasRemoteForwarded) {
+        return { mergeContent: localContent, hasChanges: true, hasConflicts: false };
+    }
+    const localByCommand = byCommand(local);
+    const remoteByCommand = byCommand(remote);
+    const baseByCommand = base ? byCommand(base) : null;
+    const localToRemoteByCommand = compareByCommand(localByCommand, remoteByCommand, normalizedKeys);
+    const baseToLocalByCommand = baseByCommand ? compareByCommand(baseByCommand, localByCommand, normalizedKeys) : { added: [...( localByCommand.keys())].reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    const baseToRemoteByCommand = baseByCommand ? compareByCommand(baseByCommand, remoteByCommand, normalizedKeys) : { added: [...( remoteByCommand.keys())].reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    const commandsMergeResult = computeMergeResult(localToRemoteByCommand, baseToLocalByCommand, baseToRemoteByCommand);
+    let mergeContent = localContent;
+    for (const command of ( commandsMergeResult.removed.values())) {
+        if (( commandsMergeResult.conflicts.has(command))) {
+            continue;
+        }
+        mergeContent = removeKeybindings(mergeContent, command, formattingOptions);
+    }
+    for (const command of ( commandsMergeResult.added.values())) {
+        if (( commandsMergeResult.conflicts.has(command))) {
+            continue;
+        }
+        const keybindings = remoteByCommand.get(command);
+        if (( keybindings.some(keybinding => keybinding.command !== `-${command}` && ( keybindingsMergeResult.conflicts.has(normalizedKeys[keybinding.key]))))) {
+            commandsMergeResult.conflicts.add(command);
+            continue;
+        }
+        mergeContent = addKeybindings(mergeContent, keybindings, formattingOptions);
+    }
+    for (const command of ( commandsMergeResult.updated.values())) {
+        if (( commandsMergeResult.conflicts.has(command))) {
+            continue;
+        }
+        const keybindings = remoteByCommand.get(command);
+        if (( keybindings.some(keybinding => keybinding.command !== `-${command}` && ( keybindingsMergeResult.conflicts.has(normalizedKeys[keybinding.key]))))) {
+            commandsMergeResult.conflicts.add(command);
+            continue;
+        }
+        mergeContent = updateKeybindings(mergeContent, command, keybindings, formattingOptions);
+    }
+    return { mergeContent, hasChanges: true, hasConflicts: commandsMergeResult.conflicts.size > 0 };
+}
+function computeMergeResult(localToRemote, baseToLocal, baseToRemote) {
+    const added = ( new Set());
+    const removed = ( new Set());
+    const updated = ( new Set());
+    const conflicts = ( new Set());
+    for (const key of ( baseToLocal.removed.values())) {
+        if (( baseToRemote.updated.has(key))) {
+            conflicts.add(key);
+        }
+    }
+    for (const key of ( baseToRemote.removed.values())) {
+        if (( conflicts.has(key))) {
+            continue;
+        }
+        if (( baseToLocal.updated.has(key))) {
+            conflicts.add(key);
+        }
+        else {
+            removed.add(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);
+            }
+        }
+    }
+    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 {
+            added.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);
+            }
+        }
+    }
+    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 {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated, conflicts };
+}
+function computeMergeResultByKeybinding(local, remote, base, normalizedKeys) {
+    const empty = ( new Set());
+    const localByKeybinding = byKeybinding(local, normalizedKeys);
+    const remoteByKeybinding = byKeybinding(remote, normalizedKeys);
+    const baseByKeybinding = base ? byKeybinding(base, normalizedKeys) : null;
+    const localToRemoteByKeybinding = compareByKeybinding(localByKeybinding, remoteByKeybinding);
+    if (localToRemoteByKeybinding.added.size === 0 && localToRemoteByKeybinding.removed.size === 0 && localToRemoteByKeybinding.updated.size === 0) {
+        return { hasLocalForwarded: false, hasRemoteForwarded: false, added: empty, removed: empty, updated: empty, conflicts: empty };
+    }
+    const baseToLocalByKeybinding = baseByKeybinding ? compareByKeybinding(baseByKeybinding, localByKeybinding) : { added: [...( localByKeybinding.keys())].reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    if (baseToLocalByKeybinding.added.size === 0 && baseToLocalByKeybinding.removed.size === 0 && baseToLocalByKeybinding.updated.size === 0) {
+        return { hasLocalForwarded: false, hasRemoteForwarded: true, added: empty, removed: empty, updated: empty, conflicts: empty };
+    }
+    const baseToRemoteByKeybinding = baseByKeybinding ? compareByKeybinding(baseByKeybinding, remoteByKeybinding) : { added: [...( remoteByKeybinding.keys())].reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    if (baseToRemoteByKeybinding.added.size === 0 && baseToRemoteByKeybinding.removed.size === 0 && baseToRemoteByKeybinding.updated.size === 0) {
+        return { hasLocalForwarded: true, hasRemoteForwarded: false, added: empty, removed: empty, updated: empty, conflicts: empty };
+    }
+    const { added, removed, updated, conflicts } = computeMergeResult(localToRemoteByKeybinding, baseToLocalByKeybinding, baseToRemoteByKeybinding);
+    return { hasLocalForwarded: true, hasRemoteForwarded: true, added, removed, updated, conflicts };
+}
+function byKeybinding(keybindings, keys) {
+    const map = ( new Map());
+    for (const keybinding of keybindings) {
+        const key = keys[keybinding.key];
+        let value = map.get(key);
+        if (!value) {
+            value = [];
+            map.set(key, value);
+        }
+        value.push(keybinding);
+    }
+    return map;
+}
+function byCommand(keybindings) {
+    const map = ( new Map());
+    for (const keybinding of keybindings) {
+        const command = keybinding.command[0] === '-' ? keybinding.command.substring(1) : keybinding.command;
+        let value = map.get(command);
+        if (!value) {
+            value = [];
+            map.set(command, value);
+        }
+        value.push(keybinding);
+    }
+    return map;
+}
+function compareByKeybinding(from, to) {
+    const fromKeys = [...( from.keys())];
+    const toKeys = [...( to.keys())];
+    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 value1 = ( from.get(key).map(keybinding => ({ ...keybinding, ...{ key } })));
+        const value2 = ( to.get(key).map(keybinding => ({ ...keybinding, ...{ key } })));
+        if (!equals(value1, value2, (a, b) => isSameKeybinding(a, b))) {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated };
+}
+function compareByCommand(from, to, normalizedKeys) {
+    const fromKeys = [...( from.keys())];
+    const toKeys = [...( to.keys())];
+    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 value1 = ( from.get(key).map(
+            keybinding => ({ ...keybinding, ...{ key: normalizedKeys[keybinding.key] } })
+        ));
+        const value2 = ( to.get(key).map(
+            keybinding => ({ ...keybinding, ...{ key: normalizedKeys[keybinding.key] } })
+        ));
+        if (!areSameKeybindingsWithSameCommand(value1, value2)) {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated };
+}
+function areSameKeybindingsWithSameCommand(value1, value2) {
+    if (!equals(value1.filter(({ command }) => command[0] !== '-'), value2.filter(({ command }) => command[0] !== '-'), (a, b) => isSameKeybinding(a, b))) {
+        return false;
+    }
+    if (!equals(value1.filter(({ command }) => command[0] === '-'), value2.filter(({ command }) => command[0] === '-'), (a, b) => isSameKeybinding(a, b))) {
+        return false;
+    }
+    return true;
+}
+function isSameKeybinding(a, b) {
+    if (a.command !== b.command) {
+        return false;
+    }
+    if (a.key !== b.key) {
+        return false;
+    }
+    const whenA = ContextKeyExpr.deserialize(a.when);
+    const whenB = ContextKeyExpr.deserialize(b.when);
+    if ((whenA && !whenB) || (!whenA && whenB)) {
+        return false;
+    }
+    if (whenA && whenB && !whenA.equals(whenB)) {
+        return false;
+    }
+    if (!equals$1(a.args, b.args)) {
+        return false;
+    }
+    return true;
+}
+function addKeybindings(content, keybindings, formattingOptions) {
+    for (const keybinding of keybindings) {
+        content = edit(content, [-1], keybinding, formattingOptions);
+    }
+    return content;
+}
+function removeKeybindings(content, command, formattingOptions) {
+    const keybindings = parseKeybindings(content);
+    for (let index = keybindings.length - 1; index >= 0; index--) {
+        if (keybindings[index].command === command || keybindings[index].command === `-${command}`) {
+            content = edit(content, [index], undefined, formattingOptions);
+        }
+    }
+    return content;
+}
+function updateKeybindings(content, command, keybindings, formattingOptions) {
+    const allKeybindings = parseKeybindings(content);
+    const location = allKeybindings.findIndex(keybinding => keybinding.command === command || keybinding.command === `-${command}`);
+    for (let index = allKeybindings.length - 1; index >= 0; index--) {
+        if (allKeybindings[index].command === command || allKeybindings[index].command === `-${command}`) {
+            content = edit(content, [index], undefined, formattingOptions);
+        }
+    }
+    for (let index = keybindings.length - 1; index >= 0; index--) {
+        content = edit(content, [location], keybindings[index], formattingOptions);
+    }
+    return content;
+}
+export { merge };

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

@@ -0,0 +1,316 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isNonEmptyArray } from '../../../base/common/arrays.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
+import { Event } from '../../../base/common/event.js';
+import { parse } from '../../../base/common/json.js';
+import { OS } from '../../../base/common/platform.js';
+import { isUndefined } from '../../../base/common/types.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
+import { IEnvironmentService } from '../../environment/common/environment.js';
+import { IFileService } from '../../files/common/files.js';
+import { IStorageService } from '../../storage/common/storage.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
+import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.js';
+import { AbstractJsonFileSynchroniser, AbstractInitializer } from './abstractSynchronizer.js';
+import { merge } from './keybindingsMerge.js';
+import { USER_DATA_SYNC_SCHEME, UserDataSyncError, CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM, IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncLogService, IUserDataSyncEnablementService, IUserDataSyncUtilService } from './userDataSync.js';
+function getKeybindingsContentFromSyncContent(syncContent, platformSpecific, logService) {
+    try {
+        const parsed = JSON.parse(syncContent);
+        if (!platformSpecific) {
+            return isUndefined(parsed.all) ? null : parsed.all;
+        }
+        switch (OS) {
+            case 2 :
+                return isUndefined(parsed.mac) ? null : parsed.mac;
+            case 3 :
+                return isUndefined(parsed.linux) ? null : parsed.linux;
+            case 1 :
+                return isUndefined(parsed.windows) ? null : parsed.windows;
+        }
+    }
+    catch (e) {
+        logService.error(e);
+        return null;
+    }
+}
+let KeybindingsSynchroniser = class KeybindingsSynchroniser extends AbstractJsonFileSynchroniser {
+    constructor(profile, collection, userDataSyncStoreService, userDataSyncLocalStoreService, logService, configurationService, userDataSyncEnablementService, fileService, environmentService, storageService, userDataSyncUtilService, telemetryService, uriIdentityService) {
+        super(profile.keybindingsResource, { syncResource: "keybindings" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, userDataSyncUtilService, configurationService, uriIdentityService);
+        this.version = 2;
+        this.previewResource = this.extUri.joinPath(this.syncPreviewFolder, 'keybindings.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._register(Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('settingsSync.keybindingsPerPlatform'))(() => this.triggerLocalChange()));
+    }
+    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine, userDataSyncConfiguration) {
+        const remoteContent = remoteUserData.syncData ? getKeybindingsContentFromSyncContent(remoteUserData.syncData.content, userDataSyncConfiguration.keybindingsPerPlatform ?? this.syncKeybindingsPerPlatform(), this.logService) : null;
+        lastSyncUserData = lastSyncUserData === null && isRemoteDataFromCurrentMachine ? remoteUserData : lastSyncUserData;
+        const lastSyncContent = lastSyncUserData ? this.getKeybindingsContentFromLastSyncUserData(lastSyncUserData) : null;
+        const fileContent = await this.getLocalFileContent();
+        const formattingOptions = await this.getFormattingOptions();
+        let mergedContent = null;
+        let hasLocalChanged = false;
+        let hasRemoteChanged = false;
+        let hasConflicts = false;
+        if (remoteContent) {
+            let localContent = fileContent ? ( fileContent.value.toString()) : '[]';
+            localContent = localContent || '[]';
+            if (this.hasErrors(localContent, true)) {
+                throw new UserDataSyncError(localizeWithPath('vs/platform/userDataSync/common/keybindingsSync', 'errorInvalidSettings', "Unable to sync keybindings because the content in the file is not valid. Please open the file and correct it."), "LocalInvalidContent" , this.resource);
+            }
+            if (!lastSyncContent
+                || lastSyncContent !== localContent
+                || lastSyncContent !== remoteContent
+            ) {
+                this.logService.trace(`${this.syncResourceLogLabel}: Merging remote keybindings with local keybindings...`);
+                const result = await merge(localContent, remoteContent, lastSyncContent, formattingOptions, this.userDataSyncUtilService);
+                if (result.hasChanges) {
+                    mergedContent = result.mergeContent;
+                    hasConflicts = result.hasConflicts;
+                    hasLocalChanged = hasConflicts || result.mergeContent !== localContent;
+                    hasRemoteChanged = hasConflicts || result.mergeContent !== remoteContent;
+                }
+            }
+        }
+        else if (fileContent) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Remote keybindings does not exist. Synchronizing keybindings for the first time.`);
+            mergedContent = ( fileContent.value.toString());
+            hasRemoteChanged = true;
+        }
+        const previewResult = {
+            content: hasConflicts ? lastSyncContent : mergedContent,
+            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 = this.getKeybindingsContentFromLastSyncUserData(lastSyncUserData);
+        if (lastSyncContent === null) {
+            return true;
+        }
+        const fileContent = await this.getLocalFileContent();
+        const localContent = fileContent ? ( fileContent.value.toString()) : '';
+        const formattingOptions = await this.getFormattingOptions();
+        const result = await merge(localContent || '[]', lastSyncContent, lastSyncContent, formattingOptions, this.userDataSyncUtilService);
+        return result.hasConflicts || result.mergeContent !== lastSyncContent;
+    }
+    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];
+        let { content, localChange, remoteChange } = resourcePreviews[0][1];
+        if (localChange === 0  && remoteChange === 0 ) {
+            this.logService.info(`${this.syncResourceLogLabel}: No changes found during synchronizing keybindings.`);
+        }
+        if (content !== null) {
+            content = content.trim();
+            content = content || '[]';
+            if (this.hasErrors(content, true)) {
+                throw new UserDataSyncError(localizeWithPath('vs/platform/userDataSync/common/keybindingsSync', 'errorInvalidSettings', "Unable to sync keybindings because the content in the file is not valid. Please open the file and correct it."), "LocalInvalidContent" , this.resource);
+            }
+        }
+        if (localChange !== 0 ) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating local keybindings...`);
+            if (fileContent) {
+                await this.backupLocal(this.toSyncContent(( fileContent.value.toString())));
+            }
+            await this.updateLocalFileContent(content || '[]', fileContent, force);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated local keybindings`);
+        }
+        if (remoteChange !== 0 ) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating remote keybindings...`);
+            const remoteContents = this.toSyncContent(content || '[]', remoteUserData.syncData?.content);
+            remoteUserData = await this.updateRemoteUserData(remoteContents, force ? null : remoteUserData.ref);
+            this.logService.info(`${this.syncResourceLogLabel}: Updated remote keybindings`);
+        }
+        try {
+            await this.fileService.del(this.previewResource);
+        }
+        catch (e) {  }
+        if (lastSyncUserData?.ref !== remoteUserData.ref) {
+            this.logService.trace(`${this.syncResourceLogLabel}: Updating last synchronized keybindings...`);
+            await this.updateLastSyncUserData(remoteUserData, { platformSpecific: this.syncKeybindingsPerPlatform() });
+            this.logService.info(`${this.syncResourceLogLabel}: Updated last synchronized keybindings`);
+        }
+    }
+    async hasLocalData() {
+        try {
+            const localFileContent = await this.getLocalFileContent();
+            if (localFileContent) {
+                const keybindings = parse(( localFileContent.value.toString()));
+                if (isNonEmptyArray(keybindings)) {
+                    return true;
+                }
+            }
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    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;
+    }
+    getKeybindingsContentFromLastSyncUserData(lastSyncUserData) {
+        if (!lastSyncUserData.syncData) {
+            return null;
+        }
+        if (lastSyncUserData.platformSpecific !== undefined && lastSyncUserData.platformSpecific !== this.syncKeybindingsPerPlatform()) {
+            return null;
+        }
+        return getKeybindingsContentFromSyncContent(lastSyncUserData.syncData.content, this.syncKeybindingsPerPlatform(), this.logService);
+    }
+    toSyncContent(keybindingsContent, syncContent) {
+        let parsed = {};
+        try {
+            parsed = JSON.parse(syncContent || '{}');
+        }
+        catch (e) {
+            this.logService.error(e);
+        }
+        if (this.syncKeybindingsPerPlatform()) {
+            delete parsed.all;
+        }
+        else {
+            parsed.all = keybindingsContent;
+        }
+        switch (OS) {
+            case 2 :
+                parsed.mac = keybindingsContent;
+                break;
+            case 3 :
+                parsed.linux = keybindingsContent;
+                break;
+            case 1 :
+                parsed.windows = keybindingsContent;
+                break;
+        }
+        return JSON.stringify(parsed);
+    }
+    syncKeybindingsPerPlatform() {
+        return !!this.configurationService.getValue(CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM);
+    }
+};
+KeybindingsSynchroniser = ( __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, IUserDataSyncUtilService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IUriIdentityService))
+], KeybindingsSynchroniser));
+let KeybindingsInitializer = class KeybindingsInitializer extends AbstractInitializer {
+    constructor(fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService) {
+        super("keybindings" , userDataProfilesService, environmentService, logService, fileService, storageService, uriIdentityService);
+    }
+    async doInitialize(remoteUserData) {
+        const keybindingsContent = remoteUserData.syncData ? this.getKeybindingsContentFromSyncContent(remoteUserData.syncData.content) : null;
+        if (!keybindingsContent) {
+            this.logService.info('Skipping initializing keybindings because remote keybindings does not exist.');
+            return;
+        }
+        const isEmpty = await this.isEmpty();
+        if (!isEmpty) {
+            this.logService.info('Skipping initializing keybindings because local keybindings exist.');
+            return;
+        }
+        await this.fileService.writeFile(this.userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsContent));
+        await this.updateLastSyncUserData(remoteUserData);
+    }
+    async isEmpty() {
+        try {
+            const fileContent = await this.fileService.readFile(this.userDataProfilesService.defaultProfile.settingsResource);
+            const keybindings = parse(( fileContent.value.toString()));
+            return !isNonEmptyArray(keybindings);
+        }
+        catch (error) {
+            return error.fileOperationResult === 1 ;
+        }
+    }
+    getKeybindingsContentFromSyncContent(syncContent) {
+        try {
+            return getKeybindingsContentFromSyncContent(syncContent, true, this.logService);
+        }
+        catch (e) {
+            this.logService.error(e);
+            return null;
+        }
+    }
+};
+KeybindingsInitializer = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, IUserDataSyncLogService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IUriIdentityService))
+], KeybindingsInitializer));
+export { KeybindingsInitializer, KeybindingsSynchroniser, getKeybindingsContentFromSyncContent };