@fluidframework/tree 2.52.0 → 2.53.0

package/lib/feature-libraries/modular-schema/modularChangeFamily.js

@@ -4,7 +4,7 @@
  */
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, makeDetachedNodeId, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, } from "../../core/index.js";
+import { EditBuilder, makeDetachedNodeId, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, mapTaggedChange, } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, newTupleBTree, mergeTupleBTrees, RangeMap, balancedReduce, } from "../../util/index.js";
 import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
@@ -89,22 +89,12 @@ export class ModularChangeFamily {
             refreshers: allRefreshers,
         });
     }
-    composeAllFields(change1, change2, revInfos, idState) {
-        if (hasConflicts(change1) && hasConflicts(change2)) {
-            return {
-                fieldChanges: new Map(),
-                nodeChanges: newTupleBTree(),
-                nodeToParent: newTupleBTree(),
-                nodeAliases: newTupleBTree(),
-                crossFieldKeys: newCrossFieldKeyTable(),
-            };
-        }
-        else if (hasConflicts(change1)) {
-            return change2;
-        }
-        else if (hasConflicts(change2)) {
-            return change1;
-        }
+    composeAllFields(potentiallyConflictedChange1, potentiallyConflictedChange2, revInfos, idState) {
+        // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
+        // This means that compose must preserve declarations (e.g., new cells) made by conflicted changes (so that we can rebase over the composition).
+        // TODO: remove once AB#46104 is completed
+        const change1 = this.getEffectiveChange(potentiallyConflictedChange1);
+        const change2 = this.getEffectiveChange(potentiallyConflictedChange2);
         const genId = idAllocatorFromState(idState);
         const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
         // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
@@ -415,10 +405,12 @@ export class ModularChangeFamily {
         }
         return inverse;
     }
-    rebase(taggedChange, over, revisionMetadata) {
-        if (hasConflicts(over.change)) {
-            return taggedChange.change;
-        }
+    rebase(taggedChange, potentiallyConflictedOver, revisionMetadata) {
+        // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
+        // This means that we must rebase over a muted version of the conflicted changeset.
+        // That is, a version that includes its declarations (e.g., new cells) but not its changes.
+        // TODO: remove once AB#46104 is completed
+        const over = mapTaggedChange(potentiallyConflictedOver, this.getEffectiveChange(potentiallyConflictedOver.change));
         const change = taggedChange.change;
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
@@ -864,6 +856,43 @@ export class ModularChangeFamily {
         }
         return numChildren;
     }
+    getEffectiveChange(change) {
+        if (hasConflicts(change)) {
+            return this.muteChange(change);
+        }
+        return change;
+    }
+    /**
+     * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.
+     */
+    muteChange(change) {
+        const muted = {
+            ...change,
+            crossFieldKeys: newCrossFieldKeyTable(),
+            fieldChanges: this.muteFieldChanges(change.fieldChanges),
+            nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
+        };
+        return muted;
+    }
+    muteNodeChange(change) {
+        if (change.fieldChanges === undefined) {
+            return change;
+        }
+        return {
+            ...change,
+            fieldChanges: this.muteFieldChanges(change.fieldChanges),
+        };
+    }
+    muteFieldChanges(change) {
+        return new Map(Array.from(change.entries(), ([key, value]) => [key, this.muteFieldChange(value)]));
+    }
+    muteFieldChange(change) {
+        const handler = getChangeHandler(this.fieldKinds, change.fieldKind);
+        return {
+            fieldKind: change.fieldKind,
+            change: brand(handler.rebaser.mute(change.change)),
+        };
+    }
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {