@fluidframework/tree 2.74.0-370705 → 2.80.0

package/lib/feature-libraries/sequence-field/utils.js

@@ -4,7 +4,7 @@
  */
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { areEqualChangeAtomIdOpts, areEqualChangeAtomIds, makeChangeAtomId, } from "../../core/index.js";
-import { areAdjacentIntegerRanges, brand } from "../../util/index.js";
+import { brand } from "../../util/index.js";
 import { CrossFieldTarget, } from "../modular-schema/index.js";
 import { NoopMarkType, } from "./types.js";
 export function isEmpty(change) {
@@ -21,14 +21,22 @@ export function createEmpty() {
 export function getNestedChanges(change) {
     const output = [];
     let inputIndex = 0;
+    let outputIndex = 0;
     for (const mark of change) {
         const { changes, count } = mark;
         if (changes !== undefined) {
-            output.push([changes, inputIndex]);
+            output.push([
+                changes,
+                areInputCellsEmpty(mark) ? undefined : inputIndex /* inputIndex */,
+                areOutputCellsEmpty(mark) ? undefined : outputIndex /* outputIndex */,
+            ]);
         }
         if (!areInputCellsEmpty(mark)) {
             inputIndex += count;
         }
+        if (!areOutputCellsEmpty(mark)) {
+            outputIndex += count;
+        }
     }
     return output;
 }
@@ -36,9 +44,10 @@ export function isNewAttach(mark, revision) {
     return isNewAttachEffect(mark, mark.cellId, revision);
 }
 export function isNewAttachEffect(effect, cellId, revision) {
-    return (isAttach(effect) &&
+    return ((isAttach(effect) &&
         cellId !== undefined &&
-        (effect.revision ?? revision) === (cellId.revision ?? revision));
+        (effect.revision ?? revision) === (cellId.revision ?? revision)) ||
+        (isAttachAndDetachEffect(effect) && isNewAttachEffect(effect.attach, cellId, revision)));
 }
 export function isRename(mark) {
     return mark.type === "Rename";
@@ -47,7 +56,7 @@ export function isInsert(mark) {
     return mark.type === "Insert";
 }
 export function isAttach(effect) {
-    return effect.type === "Insert";
+    return effect.type === "Insert" || effect.type === "MoveIn";
 }
 export function isReattach(mark) {
     return isReattachEffect(mark, mark.cellId);
@@ -65,19 +74,16 @@ export function getInputCellId(mark) {
     return mark.cellId;
 }
 export function getOutputCellId(mark) {
-    const type = mark.type;
-    switch (type) {
-        case NoopMarkType:
-            return getInputCellId(mark);
-        case "Insert":
-            return undefined;
-        case "Remove":
-            return getDetachOutputCellId(mark);
-        case "Rename":
-            return mark.idOverride;
-        default:
-            unreachableCase(type);
+    if (isDetach(mark) || isRename(mark)) {
+        return getDetachOutputCellId(mark);
     }
+    else if (markFillsCells(mark)) {
+        return undefined;
+    }
+    else if (isAttachAndDetachEffect(mark)) {
+        return getDetachOutputCellId(mark.detach);
+    }
+    return getInputCellId(mark);
 }
 export function cellSourcesFromMarks(marks, contextGetter) {
     const set = new Set();
@@ -128,9 +134,9 @@ export function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, ol
         // If both changesets know of both cells, but we've been asked to compare different cells,
         // Then either the changesets they originate from do not represent the same context,
         // or the ordering of their cells in inconsistent.
-        // The only exception to this is when we're composing anonymous changesets in a transaction.
-        assert(oldMarkCell.revision === undefined && newMarkCell.revision === undefined, 0x8a0 /* Inconsistent cell ordering */);
-        // We are composing anonymous changesets in a transaction. The new changeset is creating a cell in a gap
+        // The only exception to this is when we're composing changesets in a transaction since they have the same revision but different sets of cells.
+        assert(oldMarkCell.revision === newMarkCell.revision, 0x8a0 /* Inconsistent cell ordering */);
+        // We are composing changesets in a transaction. The new changeset is creating a cell in a gap
         // where the old changeset knows of some now empty cell. We order the new cell relative to the old cell in a
         // way that is consistent with its tie-breaking behavior should the old cell be concurrently re-filled.
         // Since only tie-break left is supported at the moment, the new cell comes first.
@@ -160,77 +166,137 @@ export function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, ol
         assert(oldMarkCell.revision !== undefined, 0x8a1 /* Old mark cell should have a revision */);
         // Note that these indices are for ordering the revisions in which the cells were named, not the revisions
         // of the changesets in which the marks targeting these cells appear.
-        const revisionComparison = metadata.compareRevisions(oldMarkCell.revision, newMarkCell.revision);
+        const oldCellRevisionIndex = metadata.getIndex(oldMarkCell.revision);
+        const newCellRevisionIndex = metadata.getIndex(newMarkCell.revision);
         // If the metadata defines an ordering for the revisions then the cell from the newer revision comes first.
-        if (revisionComparison !== 0) {
-            return revisionComparison > 0 ? CellOrder.NewThenOld : CellOrder.OldThenNew;
-        }
-        // While it is possible for both marks to refer to cells that were named in revisions that are outside
-        // the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
-        // changesets should have tombstones or marks for both cells.
-        //
-        // To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
-        // original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
-        // ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
-        //        |        └─...─(new)
-        //        └─...─(old)
-        // In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
-        // been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
-        // The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
-        // `new` refers to so long as those cells were not created on `new`'s branch.
-        // Note that the change that contains the superset of cells (again, ignoring cells created on the other
-        // change's branch) is not always the older change. Consider the following scenario:
-        // ...─(Ti)─...─(Tj)─...─(old')─(new')
-        //        |        └─...─(old)
-        //        └─...─(new)
-        //
-        // The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
-        // the examples above) with the same resolution.
-        assert(false, 0x8a2 /* Invalid cell ordering scenario */);
+        if (newCellRevisionIndex !== undefined && oldCellRevisionIndex !== undefined) {
+            return newCellRevisionIndex > oldCellRevisionIndex
+                ? CellOrder.NewThenOld
+                : CellOrder.OldThenNew;
+        }
+        if (newCellRevisionIndex === undefined && oldCellRevisionIndex === undefined) {
+            // While it is possible for both marks to refer to cells that were named in revisions that are outside
+            // the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
+            // changesets should have tombstones or marks for both cells.
+            //
+            // To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
+            // original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
+            // ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
+            //        |        └─...─(new)
+            //        └─...─(old)
+            // In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
+            // been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
+            // The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
+            // `new` refers to so long as those cells were not created on `new`'s branch.
+            // Note that the change that contains the superset of cells (again, ignoring cells created on the other
+            // change's branch) is not always the older change. Consider the following scenario:
+            // ...─(Ti)─...─(Tj)─...─(old')─(new')
+            //        |        └─...─(old)
+            //        └─...─(new)
+            //
+            // The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
+            // the examples above) with the same resolution.
+            assert(false, 0x8a2 /* Invalid cell ordering scenario */);
+        }
+        // The absence of metadata for a cell with a defined revision means that the cell is from a revision that
+        // predates the edits that are within the scope of the metadata. Such a cell is therefore older than the one
+        // for which we do have metadata.
+        return oldCellRevisionIndex === undefined ? CellOrder.NewThenOld : CellOrder.OldThenNew;
     }
 }
 /**
  * Gets the ID of the cell in the output context of the given detach `mark`.
  */
 export function getDetachOutputCellId(mark) {
-    if (mark.cellRename !== undefined) {
-        return mark.cellRename;
+    if (isRename(mark)) {
+        return mark.idOverride;
     }
-    if (mark.detachCellId !== undefined) {
-        return mark.detachCellId;
+    if (mark.idOverride !== undefined) {
+        return mark.idOverride;
     }
-    return getDetachedRootId(mark);
-}
-/**
- * Gets the ID of the node to be attached in the input context of the given detach `mark`.
- */
-export function getAttachedRootId(mark) {
-    return makeChangeAtomId(mark.id, mark.revision);
+    return mark.revision === undefined
+        ? { localId: mark.id }
+        : { revision: mark.revision, localId: mark.id };
 }
 /**
  * Gets the ID of the detached node in the output context of the given detach `mark`.
  */
-export function getDetachedRootId(mark) {
-    return makeChangeAtomId(mark.id, mark.revision);
-}
-export function getMovedNodeId(mark) {
-    return makeChangeAtomId(mark.id, mark.revision);
+export function getDetachedNodeId(mark) {
+    switch (mark.type) {
+        case "Rename":
+        case "Remove": {
+            return getDetachOutputCellId(mark);
+        }
+        case "MoveOut": {
+            return makeChangeAtomId(mark.id, mark.revision);
+        }
+        default: {
+            unreachableCase(mark);
+        }
+    }
 }
 /**
  * Preserves the semantics of the given `mark` but repackages it into a `DetachOfRemovedNodes` when possible.
  */
 export function normalizeCellRename(cellId, count, attach, detach) {
-    const outputId = getDetachOutputCellId(detach);
-    // Note that the output ID may be the same as the cellId. In such a scenario,
-    // we output an (impact-less) Rename mark anyway (as opposed to a Skip)
-    // because the resulting Rename may be rebased over other changes that rename the input cell,
-    // eventually leading to an impactful rename.
+    if (attach.type === "MoveIn") {
+        if (detach.type === "MoveOut") {
+            const outputId = getDetachOutputCellId(detach);
+            // Note that the output ID may be the same as the cellId. In such a scenario,
+            // we output an (impact-less) Rename mark anyway (as opposed to a Skip)
+            // because the resulting Rename may be rebased over other changes that rename the input cell,
+            // eventually leading to an impactful rename.
+            return {
+                type: "Rename",
+                count,
+                cellId,
+                idOverride: outputId,
+            };
+        }
+    }
+    else {
+        // Normalization: when the attach is an insert/revive, we rely on the implicit reviving semantics of the
+        // detach instead of using an explicit revive effect in an AttachAndDetach
+        return {
+            ...detach,
+            count,
+            cellId,
+        };
+    }
     return {
-        type: "Rename",
+        type: "AttachAndDetach",
+        attach,
+        detach,
+        count,
+        cellId,
+    };
+}
+/**
+ * Preserves the semantics of the given `mark` but repackages it into an `AttachAndDetach` mark if it is not already one.
+ */
+export function asAttachAndDetach(mark) {
+    if (mark.type === "AttachAndDetach") {
+        return mark;
+    }
+    const { cellId, count, changes, revision, ...effect } = mark;
+    const attachAndDetach = {
+        type: "AttachAndDetach",
         count,
         cellId,
-        idOverride: outputId,
+        attach: {
+            type: "Insert",
+            id: mark.id,
+        },
+        detach: effect,
     };
+    if (changes !== undefined) {
+        attachAndDetach.changes = changes;
+    }
+    if (revision !== undefined) {
+        attachAndDetach.attach.revision = revision;
+        attachAndDetach.detach.revision = revision;
+    }
+    return attachAndDetach;
 }
 export function cloneMark(mark) {
     const clone = { ...cloneMarkEffect(mark), count: mark.count };
@@ -241,6 +307,10 @@ export function cloneMark(mark) {
 }
 export function cloneMarkEffect(effect) {
     const clone = { ...effect };
+    if (clone.type === "AttachAndDetach") {
+        clone.attach = cloneMarkEffect(clone.attach);
+        clone.detach = cloneMarkEffect(clone.detach);
+    }
     return clone;
 }
 export function cloneCellId(id) {
@@ -272,22 +342,51 @@ export function markFillsCells(mark) {
 export function markHasCellEffect(mark) {
     return areInputCellsEmpty(mark) !== areOutputCellsEmpty(mark);
 }
+export function isAttachAndDetachEffect(effect) {
+    return effect.type === "AttachAndDetach";
+}
+export function isDetachOfRemovedNodes(mark) {
+    return isDetach(mark) && mark.cellId !== undefined;
+}
+export function isImpactfulCellRename(mark) {
+    return (isAttachAndDetachEffect(mark) || isDetachOfRemovedNodes(mark)) && isImpactful(mark);
+}
 export function areInputCellsEmpty(mark) {
     return mark.cellId !== undefined;
 }
 export function areOutputCellsEmpty(mark) {
     const type = mark.type;
     switch (type) {
-        case NoopMarkType:
+        case NoopMarkType: {
             return mark.cellId !== undefined;
+        }
         case "Remove":
         case "Rename":
+        case "MoveOut":
+        case "AttachAndDetach": {
             return true;
-        case "Insert":
+        }
+        case "MoveIn":
+        case "Insert": {
             return false;
-        default:
+        }
+        default: {
             unreachableCase(type);
+        }
+    }
+}
+/**
+ * Creates a mark that is equivalent to the given `mark` but with effects removed if those have no impact in the input
+ * context of that mark.
+ *
+ * @param mark - The mark to settle. Never mutated.
+ * @returns either the original mark or a shallow clone of it with effects stripped out.
+ */
+export function settleMark(mark) {
+    if (isImpactful(mark)) {
+        return mark;
     }
+    return omitMarkEffect(mark);
 }
 /**
  * Returns true if and only iff the given `mark` would have impact on the field when applied.
@@ -299,10 +398,12 @@ export function areOutputCellsEmpty(mark) {
 export function isImpactful(mark) {
     const type = mark.type;
     switch (type) {
-        case NoopMarkType:
+        case NoopMarkType: {
             return false;
-        case "Rename":
+        }
+        case "Rename": {
             return true;
+        }
         case "Remove": {
             const inputId = getInputCellId(mark);
             if (inputId === undefined) {
@@ -312,11 +413,22 @@ export function isImpactful(mark) {
             assert(outputId !== undefined, 0x824 /* Remove marks must have an output cell ID */);
             return !areEqualChangeAtomIds(inputId, outputId);
         }
-        case "Insert":
+        case "AttachAndDetach":
+        case "MoveOut": {
+            return true;
+        }
+        case "MoveIn": {
+            // MoveIn marks always target an empty cell.
+            assert(mark.cellId !== undefined, 0x825 /* MoveIn marks should target empty cells */);
+            return true;
+        }
+        case "Insert": {
             // A Revive has no impact if the nodes are already in the document.
             return mark.cellId !== undefined;
-        default:
+        }
+        default: {
             unreachableCase(type);
+        }
     }
 }
 export function isTombstone(mark) {
@@ -339,20 +451,25 @@ export function compareCellsFromSameRevision(cell1, count1, cell2, count2) {
 }
 export function isDetach(mark) {
     const type = mark?.type;
-    return type === "Remove";
-}
-export function isPin(mark) {
-    return mark?.type === "Insert" && mark.cellId === undefined;
+    return type === "Remove" || type === "MoveOut";
 }
 export function isRemoveMark(mark) {
     return mark?.type === "Remove";
 }
-export function areMergeableChangeAtoms(lhs, lhsCount, rhs) {
+function areMergeableChangeAtoms(lhs, lhsCount, rhs) {
     if (lhs === undefined || rhs === undefined) {
         return lhs === undefined && rhs === undefined;
     }
-    return (lhs.revision === rhs.revision &&
-        areAdjacentIntegerRanges(lhs.localId, lhsCount, rhs.localId));
+    return (lhs.revision === rhs.revision && areAdjacentIdRanges(lhs.localId, lhsCount, rhs.localId));
+}
+function areAdjacentIdRanges(firstStart, firstLength, secondStart) {
+    return firstStart + firstLength === secondStart;
+}
+function haveMergeableIdOverrides(lhs, lhsCount, rhs) {
+    if (lhs.idOverride !== undefined && rhs.idOverride !== undefined) {
+        return areMergeableCellIds(lhs.idOverride, lhsCount, rhs.idOverride);
+    }
+    return (lhs.idOverride === undefined) === (rhs.idOverride === undefined);
 }
 function areMergeableCellIds(lhs, lhsCount, rhs) {
     return areMergeableChangeAtoms(lhs, lhsCount, rhs);
@@ -387,42 +504,66 @@ function tryMergeEffects(lhs, rhs, lhsCount) {
     if (rhs.type === NoopMarkType) {
         return lhs;
     }
+    if (rhs.type === "AttachAndDetach") {
+        const lhsAttachAndDetach = lhs;
+        const attach = tryMergeEffects(lhsAttachAndDetach.attach, rhs.attach, lhsCount);
+        const detach = tryMergeEffects(lhsAttachAndDetach.detach, rhs.detach, lhsCount);
+        if (attach === undefined || detach === undefined) {
+            return undefined;
+        }
+        assert(isAttach(attach) && isDetach(detach), 0x826 /* Merged marks should be same type as input marks */);
+        return { ...lhsAttachAndDetach, attach, detach };
+    }
     if (lhs.revision !== rhs.revision) {
         return undefined;
     }
-    if (isDetach(lhs) &&
-        isDetach(rhs) &&
-        !areMergeableChangeAtoms(lhs.cellRename, lhsCount, rhs.cellRename)) {
+    if (isDetach(lhs) && isDetach(rhs) && !haveMergeableIdOverrides(lhs, lhsCount, rhs)) {
         return undefined;
     }
     const type = rhs.type;
     switch (type) {
+        case "MoveIn": {
+            const lhsMoveIn = lhs;
+            if (lhsMoveIn.id + lhsCount === rhs.id &&
+                areMergeableChangeAtoms(lhsMoveIn.finalEndpoint, lhsCount, rhs.finalEndpoint)) {
+                return lhsMoveIn;
+            }
+            break;
+        }
         case "Remove": {
             const lhsDetach = lhs;
             if (lhsDetach.id + lhsCount === rhs.id &&
-                areMergeableChangeAtoms(lhsDetach.cellRename, lhsCount, rhs.cellRename) &&
-                areMergeableChangeAtoms(lhsDetach.detachCellId, lhsCount, rhs.detachCellId)) {
+                haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
                 return lhsDetach;
             }
             break;
         }
         case "Rename": {
             const lhsDetach = lhs;
-            if (areMergeableChangeAtoms(lhsDetach.idOverride, lhsCount, rhs.idOverride)) {
+            if (haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
                 return lhsDetach;
             }
             break;
         }
+        case "MoveOut": {
+            const lhsMoveOut = lhs;
+            if (lhsMoveOut.id + lhsCount === rhs.id &&
+                haveMergeableIdOverrides(lhsMoveOut, lhsCount, rhs) &&
+                areMergeableChangeAtoms(lhsMoveOut.finalEndpoint, lhsCount, rhs.finalEndpoint)) {
+                return lhsMoveOut;
+            }
+            break;
+        }
         case "Insert": {
             const lhsInsert = lhs;
-            if (lhsInsert.id + lhsCount === rhs.id &&
-                areMergeableChangeAtoms(lhsInsert.detachCellId, lhsCount, rhs.detachCellId)) {
+            if (lhsInsert.id + lhsCount === rhs.id) {
                 return lhsInsert;
             }
             break;
         }
-        default:
+        default: {
             unreachableCase(type);
+        }
     }
     return undefined;
 }
@@ -455,8 +596,9 @@ export function splitMark(mark, length) {
 export function splitMarkEffect(effect, length) {
     const type = effect.type;
     switch (type) {
-        case NoopMarkType:
+        case NoopMarkType: {
             return [effect, effect];
+        }
         case "Insert": {
             const effect1 = {
                 ...effect,
@@ -465,21 +607,23 @@ export function splitMarkEffect(effect, length) {
                 ...effect,
                 id: effect.id + length,
             };
-            if (effect.detachCellId !== undefined) {
-                effect2.detachCellId = splitDetachEvent(effect.detachCellId, length);
-            }
             return [effect1, effect2];
         }
+        case "MoveIn": {
+            const effect2 = { ...effect, id: effect.id + length };
+            const move2 = effect2;
+            if (move2.finalEndpoint !== undefined) {
+                move2.finalEndpoint = splitDetachEvent(move2.finalEndpoint, length);
+            }
+            return [effect, effect2];
+        }
         case "Remove": {
             const effect1 = { ...effect };
             const id2 = brand(effect.id + length);
             const effect2 = { ...effect, id: id2 };
             const effect2Remove = effect2;
-            if (effect2Remove.cellRename !== undefined) {
-                effect2Remove.cellRename = splitDetachEvent(effect2Remove.cellRename, length);
-            }
-            if (effect2Remove.detachCellId !== undefined) {
-                effect2Remove.detachCellId = splitDetachEvent(effect2Remove.detachCellId, length);
+            if (effect2Remove.idOverride !== undefined) {
+                effect2Remove.idOverride = splitDetachEvent(effect2Remove.idOverride, length);
             }
             return [effect1, effect2];
         }
@@ -492,8 +636,38 @@ export function splitMarkEffect(effect, length) {
             }
             return [effect1, effect2];
         }
-        default:
+        case "MoveOut": {
+            const effect2 = {
+                ...effect,
+                id: effect.id + length,
+            };
+            const return2 = effect2;
+            if (return2.idOverride !== undefined) {
+                return2.idOverride = splitDetachEvent(return2.idOverride, length);
+            }
+            if (return2.finalEndpoint !== undefined) {
+                return2.finalEndpoint = splitDetachEvent(return2.finalEndpoint, length);
+            }
+            return [effect, effect2];
+        }
+        case "AttachAndDetach": {
+            const [attach1, attach2] = splitMarkEffect(effect.attach, length);
+            const [detach1, detach2] = splitMarkEffect(effect.detach, length);
+            const effect1 = {
+                ...effect,
+                attach: attach1,
+                detach: detach1,
+            };
+            const effect2 = {
+                ...effect,
+                attach: attach2,
+                detach: detach2,
+            };
+            return [effect1, effect2];
+        }
+        default: {
             unreachableCase(type);
+        }
     }
 }
 function splitDetachEvent(detachEvent, length) {
@@ -518,11 +692,11 @@ export function omitMarkEffect(mark) {
 }
 export function withNodeChange(mark, changes) {
     const newMark = { ...mark };
-    if (changes !== undefined) {
-        newMark.changes = changes;
+    if (changes === undefined) {
+        delete newMark.changes;
     }
     else {
-        delete newMark.changes;
+        newMark.changes = changes;
     }
     return newMark;
 }
@@ -543,51 +717,81 @@ function addRevision(effect, revision) {
     if (effect.type === NoopMarkType || isRename(effect)) {
         return;
     }
+    if (effect.type === "AttachAndDetach") {
+        addRevision(effect.attach, revision);
+        addRevision(effect.detach, revision);
+        return;
+    }
     assert(effect.revision === undefined || effect.revision === revision, 0x829 /* Should not overwrite mark revision */);
     effect.revision = revision;
 }
+export function getEndpoint(effect) {
+    return effect.finalEndpoint ?? { revision: effect.revision, localId: effect.id };
+}
 export function getCrossFieldKeys(change) {
     const keys = [];
     for (const mark of change) {
-        keys.push(...getCrossFieldKeysForMark(mark, mark.count));
+        keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
     }
     return keys;
 }
-function getCrossFieldKeysForMark(mark, count) {
-    switch (mark.type) {
+function getCrossFieldKeysForMarkEffect(effect, count) {
+    switch (effect.type) {
         case "Insert": {
-            const keys = [
+            // An insert behaves like a move where the source and destination are at the same location.
+            // An insert can become a move when after rebasing.
+            return [
+                {
+                    key: {
+                        target: CrossFieldTarget.Source,
+                        revision: effect.revision,
+                        localId: effect.id,
+                    },
+                    count,
+                },
                 {
                     key: {
-                        revision: mark.revision,
-                        localId: mark.id,
                         target: CrossFieldTarget.Destination,
+                        revision: effect.revision,
+                        localId: effect.id,
                     },
                     count,
                 },
             ];
-            if (mark.cellId === undefined) {
-                // This is a pin, which is treated as a detach and attach.
-                keys.push({
-                    key: { revision: mark.revision, localId: mark.id, target: CrossFieldTarget.Source },
-                    count,
-                });
-            }
-            return keys;
         }
-        case "Remove":
+        case "MoveOut": {
             return [
                 {
                     key: {
-                        revision: mark.revision,
-                        localId: mark.id,
                         target: CrossFieldTarget.Source,
+                        revision: effect.revision,
+                        localId: effect.id,
+                    },
+                    count,
+                },
+            ];
+        }
+        case "MoveIn": {
+            return [
+                {
+                    key: {
+                        target: CrossFieldTarget.Destination,
+                        revision: effect.revision,
+                        localId: effect.id,
                     },
                     count,
                 },
             ];
-        default:
+        }
+        case "AttachAndDetach": {
+            return [
+                ...getCrossFieldKeysForMarkEffect(effect.attach, count),
+                ...getCrossFieldKeysForMarkEffect(effect.detach, count),
+            ];
+        }
+        default: {
             return [];
+        }
     }
 }
 //# sourceMappingURL=utils.js.map