core-3nweb-client-lib 0.43.20 → 0.44.1

package/build/lib-client/xsp-fs/folder-node.js

@@ -184,34 +184,15 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 const newState = this.currentState;
                 const { renamedNodes, addedNodes, removedNodes } = identifyChanges(originalState.nodes, newState.nodes);
                 for (const node of removedNodes) {
-                    const event = {
-                        type: 'entry-removal',
-                        src: 'sync',
-                        path: this.name,
-                        newVersion: this.version,
-                        name: node.name
-                    };
-                    this.broadcastEvent(event, false, node.objId);
+                    const { event, childObjId } = this.makeEntryRemovalEvent(this.version, 'sync', node);
+                    this.broadcastEvent(event, false, childObjId);
                 }
                 for (const node of addedNodes) {
-                    const event = {
-                        type: 'entry-addition',
-                        src: 'sync',
-                        entry: nodeInfoToListingEntry(node),
-                        path: this.name,
-                        newVersion: this.version
-                    };
-                    this.broadcastEvent(event, false, node.objId);
+                    const { event, childObjId } = this.makeEntryAdditionEvent(this.version, 'sync', node);
+                    this.broadcastEvent(event, false, childObjId);
                 }
                 for (const { objId, oldName, newName } of renamedNodes) {
-                    const event = {
-                        type: 'entry-renaming',
-                        src: 'sync',
-                        oldName,
-                        newName,
-                        path: this.name,
-                        newVersion: this.version
-                    };
+                    const event = this.makeEntryRenamingEvent(this.version, 'sync', newName, oldName);
                     this.broadcastEvent(event, false, objId);
                 }
                 return removedNodes;
@@ -228,6 +209,38 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             this.callRemoveObjOn('sync', nodeToRm);
         }
     }
+    makeEntryAdditionEvent(newVersion, src, node, moveLabel) {
+        const event = {
+            type: 'entry-addition',
+            src,
+            entry: nodeInfoToListingEntry(node),
+            path: this.name,
+            newVersion,
+            moveLabel
+        };
+        return { event, childObjId: node.objId };
+    }
+    makeEntryRemovalEvent(newVersion, src, { name, objId }, moveLabel) {
+        const event = {
+            type: 'entry-removal',
+            src,
+            path: this.name,
+            newVersion,
+            name,
+            moveLabel
+        };
+        return { event, childObjId: objId };
+    }
+    makeEntryRenamingEvent(newVersion, src, newName, oldName) {
+        return {
+            type: 'entry-renaming',
+            src,
+            oldName,
+            newName,
+            path: this.name,
+            newVersion
+        };
+    }
     callRemoveObjOn(src, node) {
         if (node.type === 'folder') {
             node.removeFolderObj(src);
@@ -358,64 +371,67 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 return [];
             }
             delete state.nodes[childInfo.name];
-            const event = {
-                type: 'entry-removal',
-                path: this.name,
-                src: 'local',
-                name: childInfo.name,
-                newVersion: version
-            };
-            return { event, childObjId: childInfo.objId };
+            return this.makeEntryRemovalEvent(version, 'local', childInfo);
         }).catch(noop);
         const fileExc = (0, file_1.makeFileException)('notFound', childInfo.name, exc);
         fileExc.inconsistentStateOfFS = true;
         throw fileExc;
     }
-    async adoptItemsFromRemoteVersion(opts) {
-        const { state, remote } = await this.syncStatus();
-        if ((state !== 'conflicting') && (state !== 'behind')) {
-            return;
-        }
-        const remoteVersion = versionFromRemoteBranch(remote, opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
-        if (!remoteVersion) {
-            throw 'something';
-        }
-        const { folderInfo: remoteState } = await this.readRemoteVersion(remoteVersion);
-        return await this.doChangeWhileTrackingVersion(opts === null || opts === void 0 ? void 0 : opts.localVersion, async (state) => {
-            const { inRemote, nameOverlaps, differentKeys } = diffNodes(state, remoteState);
-            if (differentKeys) {
-                throw 'something';
-            }
-            if (!inRemote) {
-                return [];
-            }
-            const addedNodes = new Set();
-            if (nameOverlaps) {
-                const postfix = opts === null || opts === void 0 ? void 0 : opts.postfixForNameOverlaps;
-                if ((postfix === undefined) || (postfix.length < 0)) {
-                    throw 'something';
-                }
-                for (const itemName of nameOverlaps) {
-                    const node = remoteState.nodes[itemName];
-                    let newName = `${itemName}${postfix}`;
-                    while (state.nodes[newName]) {
-                        newName = `${newName}${postfix}`;
-                    }
-                    node.name = newName;
-                    state.nodes[newName] = node;
-                    addedNodes.add(itemName);
-                }
-            }
-            for (const { name: itemName } of inRemote) {
-                if (addedNodes.has(itemName)) {
-                    continue;
-                }
-                const node = remoteState.nodes[itemName];
-                state.nodes[itemName] = node;
-            }
-            return [];
-        });
-    }
+    // XXX should we keep this, when merge with certain inputs will do same action
+    // async adoptItemsFromRemoteVersion(opts: OptionsToAdoptAllRemoteItems|undefined): Promise<number|undefined> {
+    // 	const { state, remote } = await this.syncStatus();
+    // 	if ((state !== 'conflicting') && (state !== 'behind')) {
+    // 		return;
+    // 	}
+    // 	const remoteVersion = versionFromRemoteBranch(remote!, opts?.remoteVersion);
+    // 	if (!remoteVersion) {
+    // 		throw 'something';
+    // 	}
+    // 	const { folderInfo: remoteState } = await this.readRemoteVersion(remoteVersion);
+    // 	const synced = undefined;
+    // 	return await this.doChangeWhileTrackingVersion(opts?.localVersion, async (state, newVersion) => {
+    // 		const { inRemote, nameOverlaps, differentKeys } = diffNodes(state, remoteState, synced);
+    // 		if (differentKeys) {
+    // 			throw makeFSSyncException(this.name, {
+    // 				message: `There are different keys, and implementation for it is not implemented, yet.`
+    // 			});
+    // 		}
+    // 		const events: { event: FSEvent; childObjId: string; }[] = [];
+    // 		if (!inRemote) {
+    // 			return events;
+    // 		}
+    // 		const addedNodes = new Set<string>();
+    // 		if (nameOverlaps) {
+    // 			const postfix = opts?.postfixForNameOverlaps;
+    // 			if ((postfix === undefined) || (postfix.length < 0)) {
+    // 				// XXX better exception
+    // 				throw 'something';
+    // 			}
+    // 			for (const itemName of nameOverlaps) {
+    // 				const node = remoteState.nodes[itemName];
+    // 				let newName = `${itemName}${postfix}`;
+    // 				while (state.nodes[newName]) {
+    // 					newName = `${newName}${postfix}`;
+    // 				}
+    // 				node.name = newName;
+    // 				state.nodes[newName] = node;
+    // 				addedNodes.add(itemName);
+    // 				const { event, childObjId } = this.makeEntryAdditionEvent(newVersion, 'sync', node);
+    // 				events.push({ event, childObjId });
+    // 			}
+    // 		}
+    // 		for (const { name: itemName } of inRemote) {
+    // 			if (addedNodes.has(itemName)) {
+    // 				continue;
+    // 			}
+    // 			const node = remoteState.nodes[itemName];
+    // 			state.nodes[itemName] = node;
+    // 			const { event, childObjId } = this.makeEntryAdditionEvent(newVersion, 'sync', node);
+    // 			events.push({ event, childObjId });
+    // 		}
+    // 		return events;
+    // 	});
+    // }
     /**
      * If no initial local version given, then this performs like doTransition(change) method.
      * When initial local version is given and check, exceptions are thrown if versions mismatch,
@@ -578,16 +594,10 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 else {
                     throw new Error(`Unknown type of node: ${type}`);
                 }
-                addToTransitionState(state, node, key);
+                const nodeInfo = addToTransitionState(state, node, key);
                 this.storage.nodes.set(node);
-                const event = {
-                    type: 'entry-addition',
-                    path: this.name,
-                    src: 'local',
-                    newVersion: version,
-                    entry: nodeToListingEntry(node)
-                };
-                return { event, childObjId: node.objId };
+                const { event, childObjId } = this.makeEntryAdditionEvent(version, 'local', nodeInfo);
+                return { event, childObjId };
             });
             return node;
         });
@@ -603,28 +613,21 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     async removeChild(f) {
         await this.doTransition(async (state, version) => {
-            const childJSON = state.nodes[f.name];
-            if (!childJSON || (childJSON.objId !== f.objId)) {
+            const child = state.nodes[f.name];
+            if (!child || (child.objId !== f.objId)) {
                 throw new Error(`Not a child given: name==${f.name}, objId==${f.objId}, parentId==${f.parentId}, this folder objId==${this.objId}`);
             }
             delete state.nodes[f.name];
-            const event = {
-                type: 'entry-removal',
-                path: this.name,
-                src: 'local',
-                name: f.name,
-                newVersion: version
-            };
-            return { event, childObjId: f.objId };
+            return this.makeEntryRemovalEvent(version, 'local', child);
         });
         // explicitly do not wait on a result of child's delete, cause if it fails
         // we just get traceable garbage, yet, the rest of a live/non-deleted tree
         // stays consistent
         this.callRemoveObjOn('local', f);
     }
-    changeChildName(initName, newName) {
+    changeChildName(oldName, newName) {
         return this.doTransition(async (state, version) => {
-            const child = state.nodes[initName];
+            const child = state.nodes[oldName];
             delete state.nodes[child.name];
             state.nodes[newName] = child;
             child.name = newName;
@@ -632,15 +635,10 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             if (childNode) {
                 childNode.name = newName;
             }
-            const event = {
-                type: 'entry-renaming',
-                path: this.name,
-                src: 'local',
-                newName,
-                oldName: initName,
-                newVersion: version
+            return {
+                event: this.makeEntryRenamingEvent(version, 'local', newName, oldName),
+                childObjId: child.objId
             };
-            return { event, childObjId: child.objId };
         });
     }
     async moveChildTo(childName, dst, nameInDst) {
@@ -659,19 +657,11 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             await this.moveChildOut(childName, childJSON.objId, moveLabel);
         }
     }
-    async moveChildOut(name, childObjId, moveLabel) {
+    async moveChildOut(name, _childObjId, moveLabel) {
         await this.doTransition(async (state, version) => {
             const child = state.nodes[name];
             delete state.nodes[name];
-            const event = {
-                type: 'entry-removal',
-                path: this.name,
-                src: 'local',
-                name,
-                newVersion: version,
-                moveLabel
-            };
-            return { event, childObjId };
+            return this.makeEntryRemovalEvent(version, 'local', child, moveLabel);
         });
     }
     async moveChildIn(newName, child, moveLabel) {
@@ -679,15 +669,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         await this.doTransition(async (state, version) => {
             child.name = newName;
             state.nodes[child.name] = child;
-            const event = {
-                type: 'entry-addition',
-                path: this.name,
-                src: 'local',
-                entry: nodeInfoToListingEntry(child),
-                newVersion: version,
-                moveLabel
-            };
-            return { event, childObjId: child.objId };
+            const { event, childObjId } = this.makeEntryAdditionEvent(version, 'local', child, moveLabel);
+            return { event, childObjId };
         });
     }
     async getFolderInThisSubTree(path, createIfMissing = false, exclusiveCreate = false) {
@@ -1030,14 +1013,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             remoteChildNode.name = childName;
             state.nodes[remoteChildNode.name] = remoteChildNode;
-            const event = {
-                type: 'entry-addition',
-                path: this.name,
-                src: 'sync',
-                entry: nodeInfoToListingEntry(remoteChildNode),
-                newVersion
-            };
-            return { event, childObjId: remoteChildNode.objId };
+            return this.makeEntryAdditionEvent(newVersion, 'sync', remoteChildNode);
         });
     }
     async replaceLocalChildWithRemote(remoteChildNode, initLocalVersion) {
@@ -1045,22 +1021,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         const newVersion = await this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             origChildNode = state.nodes[remoteChildNode.name];
             state.nodes[remoteChildNode.name] = remoteChildNode;
-            const additionEvent = {
-                type: 'entry-addition',
-                path: this.name,
-                src: 'sync',
-                entry: nodeInfoToListingEntry(remoteChildNode),
-                newVersion
-            };
-            const rmEvent = {
-                type: 'entry-removal',
-                path: this.name,
-                src: 'sync',
-                name: origChildNode.name
-            };
             return [
-                { event: rmEvent, childObjId: origChildNode.objId },
-                { event: additionEvent, childObjId: remoteChildNode.objId }
+                this.makeEntryRemovalEvent(newVersion, 'sync', origChildNode),
+                this.makeEntryAdditionEvent(newVersion, 'sync', remoteChildNode)
             ];
         });
         const origChild = await this.getOrMakeChildNodeForInfo(origChildNode);
@@ -1074,57 +1037,23 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return await this.crypto.read(srcOfRemote);
     }
     async diffCurrentAndRemote(remoteVersion) {
-        const { state, remote } = await this.syncStatus();
-        let isCurrentLocal;
-        if (state === 'behind') {
-            isCurrentLocal = false;
-        }
-        else if (state === 'conflicting') {
-            isCurrentLocal = true;
-        }
-        else {
+        const v = await this.getRemoteVersionToDiff(remoteVersion);
+        if (!v) {
             return;
         }
-        remoteVersion = versionFromRemoteBranch(remote, remoteVersion);
-        if (remoteVersion) {
-            const { folderInfo, attrs, xattrs } = await this.readRemoteVersion(remoteVersion);
-            return this.diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs);
+        else if (v.rm) {
+            return v.rmDiff;
         }
         else {
-            return this.diffWithArchivedRemote(isCurrentLocal);
+            const { isCurrentLocal, remoteVersion, syncedVersion } = v;
+            const remote = await this.readRemoteVersion(remoteVersion);
+            const synced = await this.readRemoteVersion(syncedVersion);
+            return {
+                ...this.commonDiffWithRemote(isCurrentLocal, remoteVersion, remote, syncedVersion, synced),
+                ...diffNodes(this.currentState, remote.folderInfo, synced.folderInfo),
+            };
         }
     }
-    diffWithArchivedRemote(isCurrentLocal) {
-        return {
-            currentVersion: this.version,
-            isCurrentLocal,
-            isRemoteRemoved: true,
-            ctime: {
-                current: new Date(this.attrs.ctime)
-            },
-            mtime: {
-                current: new Date(this.attrs.ctime)
-            }
-        };
-    }
-    diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs) {
-        const { ctime, mtime } = diffAttrs(this.attrs, attrs);
-        const { inCurrent, inRemote, nameOverlaps, differentKeys, differentNames } = diffNodes(this.currentState, folderInfo);
-        return {
-            currentVersion: this.version,
-            isCurrentLocal,
-            isRemoteRemoved: false,
-            remoteVersion,
-            inCurrent,
-            inRemote,
-            nameOverlaps,
-            differentKeys,
-            differentNames,
-            ctime,
-            mtime,
-            xattrs: diffXAttrs(this.xattrs, xattrs)
-        };
-    }
     async getRemoteItemNode(remoteItemName, remoteVersion) {
         const remoteChildNodeInfo = await this.getRemoteChildNodeInfo(remoteItemName, remoteVersion);
         return await this.getOrMakeChildNodeForInfo(remoteChildNodeInfo, false);
@@ -1132,6 +1061,85 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     getStorage() {
         return this.storage;
     }
+    async mergeCurrentAndRemoteVersions(opts) {
+        const diff = await this.diffCurrentAndRemote(opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
+        if (!diff) {
+            return;
+        }
+        else if (diff.isRemoteRemoved) {
+            return -1;
+        }
+        else if (!diff.isCurrentLocal) {
+            await this.adoptRemote({ remoteVersion: diff.remoteVersion });
+            return this.version;
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.localVersion) && (opts.localVersion !== diff.currentVersion)) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                versionMismatch: true,
+                message: `Given local version ${opts.localVersion} is not equal to current ${diff.currentVersion}`
+            });
+        }
+        const { added, removed, renamed, rekeyed, nameOverlaps } = diff;
+        if (rekeyed) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                message: `There are different keys, and implementation for it is not implemented, yet.`
+            });
+        }
+        if (nameOverlaps && !(opts === null || opts === void 0 ? void 0 : opts.postfixForNameOverlaps)) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                nameOverlaps,
+                message: `There are name overlaps, but prefix for adding to remote item names isn't given.`
+            });
+        }
+        const remote = await this.readRemoteVersion(diff.remoteVersion);
+        return await this.doChangeWhileTrackingVersion(diff.currentVersion, async (state, newVersion) => {
+            const nodes = state.nodes;
+            const remoteNodes = remote.folderInfo.nodes;
+            const events = [];
+            if (removed) {
+                for (const { name, removedIn } of removed) {
+                    if (removedIn === 'r') {
+                        const node = nodes[name];
+                        delete nodes[name];
+                        events.push(this.makeEntryRemovalEvent(newVersion, 'sync', node));
+                    }
+                }
+            }
+            if (renamed) {
+                for (const { local, remote, renamedIn } of renamed) {
+                    if (renamedIn === 'r') {
+                        const node = nodes[local];
+                        (0, assert_1.assert)(!!node);
+                        node.name = remote;
+                        nodes[node.name] = node;
+                        events.push({
+                            event: this.makeEntryRenamingEvent(newVersion, 'sync', remote, local),
+                            childObjId: node.objId
+                        });
+                    }
+                    else if (renamedIn === 'l&r') {
+                        // XXX use mtime to suggest which name to adopt -- TODO
+                    }
+                }
+            }
+            if (added) {
+                for (const { name, addedIn } of added) {
+                    if (addedIn === 'r') {
+                        const node = remoteNodes[name];
+                        (0, assert_1.assert)(!!node);
+                        if (nameOverlaps === null || nameOverlaps === void 0 ? void 0 : nameOverlaps.includes(name)) {
+                            while (nodes[node.name]) {
+                                node.name = `${node.name}${opts === null || opts === void 0 ? void 0 : opts.postfixForNameOverlaps}`;
+                            }
+                        }
+                        nodes[node.name] = node;
+                        events.push(this.makeEntryAdditionEvent(newVersion, 'sync', node));
+                    }
+                }
+            }
+            return events;
+        });
+    }
 }
 exports.FolderNode = FolderNode;
 Object.freeze(FolderNode.prototype);
@@ -1156,18 +1164,6 @@ function nodeInfoToListingEntry({ name, isFile, isFolder, isLink }) {
         return { name };
     }
 }
-function nodeToListingEntry({ name, type }) {
-    switch (type) {
-        case 'file':
-            return { name, isFolder: true };
-        case 'folder':
-            return { name, isFolder: true };
-        case 'link':
-            return { name, isLink: true };
-        default:
-            return { name };
-    }
-}
 function addToTransitionState(state, f, key) {
     const nodeInfo = {
         name: f.name,
@@ -1187,170 +1183,82 @@ function addToTransitionState(state, f, key) {
         throw new Error(`Unknown type of file system entity: ${f.type}`);
     }
     state.nodes[nodeInfo.name] = nodeInfo;
+    return nodeInfo;
 }
-function diffAttrs(current, remote) {
-    return {
-        ctime: {
-            current: new Date(current.ctime),
-            remote: new Date(remote.ctime)
-        },
-        mtime: {
-            current: new Date(current.mtime),
-            remote: new Date(remote.mtime)
-        }
-    };
-}
-function diffNodes(current, remote) {
-    const inRemote = [];
-    const nodesInCurrentById = new Map();
-    for (const node of Object.values(current.nodes)) {
-        nodesInCurrentById.set(node.objId, node);
-    }
+function diffNodes(current, remote, synced) {
+    const currentNodesById = orderByIds(current.nodes);
+    const syncedNodesById = orderByIds(synced.nodes);
+    const removed = [];
+    const renamed = [];
+    const added = [];
+    const rekeyed = [];
     const nameOverlaps = [];
-    const differentNames = [];
-    const differentKeys = [];
     for (const remoteNode of Object.values(remote.nodes)) {
-        const localNode = nodesInCurrentById.get(remoteNode.objId);
+        const localNode = currentNodesById.get(remoteNode.objId);
         if (localNode) {
-            if (localNode.name !== remoteNode.name) {
-                differentNames.push({
-                    localName: localNode.name,
-                    remoteName: remoteNode.name
+            if (localNode.name === remoteNode.name) {
+                // nodes are same
+            }
+            else {
+                const syncedNode = syncedNodesById.get(remoteNode.objId);
+                (0, assert_1.assert)(!!synced);
+                const localChanged = (syncedNode.name !== localNode.name);
+                const remoteChanged = (syncedNode.name !== remoteNode.name);
+                renamed.push({
+                    local: localNode.name,
+                    remote: remoteNode.name,
+                    renamedIn: (localChanged ? (remoteChanged ? 'l&r' : 'l') : 'r')
                 });
+                if (current.nodes[remoteNode.name]) {
+                    nameOverlaps.push(remoteNode.name);
+                }
             }
-            if (!areBytesEqual(localNode.key, remoteNode.key)) {
-                differentKeys.push(localNode.name);
+            if (!(0, node_in_fs_1.areBytesEqual)(localNode.key, remoteNode.key)) {
+                const syncedNode = syncedNodesById.get(remoteNode.objId);
+                (0, assert_1.assert)(!!synced);
+                const localChanged = !(0, node_in_fs_1.areBytesEqual)(localNode.key, syncedNode.key);
+                const remoteChanged = !(0, node_in_fs_1.areBytesEqual)(localNode.key, syncedNode.key);
+                rekeyed.push({
+                    local: localNode.name,
+                    remote: remoteNode.name,
+                    rekeyedIn: (localChanged ? (remoteChanged ? 'l&r' : 'l') : 'r')
+                });
             }
-            nodesInCurrentById.delete(remoteNode.objId);
+            currentNodesById.delete(localNode.objId);
         }
         else {
-            inRemote.push(nodeInfoToListingEntry(remoteNode));
+            const syncedNode = syncedNodesById.get(remoteNode.objId);
+            if (syncedNode) {
+                removed.push({ name: remoteNode.name, removedIn: 'l' });
+            }
+            else {
+                added.push({ name: remoteNode.name, addedIn: 'r' });
+            }
             if (current.nodes[remoteNode.name]) {
                 nameOverlaps.push(remoteNode.name);
             }
         }
     }
-    const inCurrent = [];
-    for (const localNode of nodesInCurrentById.values()) {
-        inCurrent.push(nodeInfoToListingEntry(localNode));
+    for (const localNode of currentNodesById.values()) {
+        const syncedNode = syncedNodesById.get(localNode.objId);
+        if (!syncedNode) {
+            added.push({ name: localNode.name, addedIn: 'l' });
+        }
     }
     return {
-        inCurrent: ((inCurrent.length > 0) ? inCurrent : undefined),
-        inRemote: ((inRemote.length > 0) ? inRemote : undefined),
-        differentNames: ((differentNames.length > 0) ? differentNames : undefined),
+        removed: ((removed.length > 0) ? removed : undefined),
+        renamed: ((renamed.length > 0) ? renamed : undefined),
+        added: ((added.length > 0) ? added : undefined),
+        rekeyed: ((rekeyed.length > 0) ? rekeyed : undefined),
         nameOverlaps: ((nameOverlaps.length > 0) ? nameOverlaps : undefined),
-        differentKeys: ((differentKeys.length > 0) ? differentKeys : undefined)
     };
 }
-function combineCheckingNameOverlaps(inCurrent, inRemote) {
-    if (inCurrent) {
-        if (inRemote) {
-            const nameOverlaps = [];
-            for (const { name: nameInCurrent } of inCurrent) {
-                if (inRemote.find(({ name }) => (name === nameInCurrent))) {
-                    nameOverlaps.push(nameInCurrent);
-                }
-            }
-            if (nameOverlaps.length > 0) {
-                return { inCurrent, inRemote, nameOverlaps };
-            }
-            else {
-                return { inCurrent, inRemote };
-            }
-        }
-        else {
-            return { inCurrent };
-        }
-    }
-    else {
-        if (inRemote) {
-            return { inRemote };
-        }
-        else {
-            return;
-        }
-    }
-}
-function diffXAttrs(current, remote) {
-    const haveCurrentXAttrs = (current && (current.list().length > 0));
-    const haveRemoteXAttrs = (remote && (remote.list().length > 0));
-    if (haveCurrentXAttrs && haveRemoteXAttrs) {
-        const inCurrent = getOnlyNotEqualXAttrs(current, remote);
-        const inRemote = getOnlyNotEqualXAttrs(remote, current);
-        return combineCheckingNameOverlaps(inCurrent, inRemote);
-    }
-    else if (haveCurrentXAttrs && !haveRemoteXAttrs) {
-        return { inCurrent: allXAttrsToDiff(current) };
-    }
-    else if (!haveCurrentXAttrs && haveRemoteXAttrs) {
-        return { inRemote: allXAttrsToDiff(remote) };
-    }
-    else {
-        return;
-    }
-}
-function allXAttrsToDiff(src) {
-    const collected = [];
-    for (const name of src.list()) {
-        const value = src.get(name);
-        if (value !== undefined) {
-            collected.push({ name, value });
-        }
+function orderByIds(nodes) {
+    const nodesById = new Map();
+    for (const node of Object.values(nodes)) {
+        nodesById.set(node.objId, node);
     }
-    return collected;
-}
-function getOnlyNotEqualXAttrs(src, exclude) {
-    const collected = [];
-    for (const name of src.list()) {
-        const valueInSrc = src.get(name);
-        if (valueInSrc === undefined) {
-            continue;
-        }
-        const valueInExclude = exclude.get(name);
-        if ((valueInExclude === undefined)
-            || !areXAttrValuesEqual(valueInSrc, valueInExclude)) {
-            collected.push({ name, value: valueInSrc });
-        }
-    }
-    return ((collected.length > 0) ? collected : undefined);
-}
-function areXAttrValuesEqual(v1, v2) {
-    if (Buffer.isBuffer(v1) || ArrayBuffer.isView(v1)) {
-        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)) {
-            return areBytesEqual(v1, v2);
-        }
-        {
-            return false;
-        }
-    }
-    else if (typeof v1 === 'string') {
-        if (typeof v2 === 'string') {
-            return (v1 === v2);
-        }
-        else {
-            return false;
-        }
-    }
-    else {
-        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)
-            || (typeof v2 === 'string')) {
-            return false;
-        }
-        else {
-            return (0, json_utils_1.deepEqual)(v1, v2);
-        }
-    }
-}
-function areBytesEqual(b1, b2) {
-    if (b1.length !== b2.length) {
-        return false;
-    }
-    for (let i = 0; i < b1.length; i += 1) {
-        if (b1[i] !== b2[i]) {
-            return false;
-        }
-    }
-    return true;
+    return nodesById;
 }
 function identifyChanges(originalNodes, newNodes) {
     const removedNodes = [];
@@ -1383,23 +1291,4 @@ function identifyChanges(originalNodes, newNodes) {
     }
     return { addedNodes, removedNodes, renamedNodes };
 }
-function versionFromRemoteBranch(remote, remoteVersion) {
-    var _a;
-    if (remote.isArchived) {
-        return;
-    }
-    if (remoteVersion) {
-        if ((remoteVersion !== remote.latest)
-            && !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(remoteVersion))) {
-            throw (0, exceptions_1.makeFSSyncException)(this.name, {
-                versionMismatch: true,
-                message: `Unknown remote version ${remoteVersion}`
-            });
-        }
-        return remoteVersion;
-    }
-    else {
-        return remote.latest;
-    }
-}
 Object.freeze(exports);