@fluidframework/tree 2.74.0 → 2.81.0-374083

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

@@ -4,8 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEndpoint = exports.withRevision = exports.withNodeChange = exports.omitMarkEffect = exports.extractMarkEffect = exports.splitMarkEffect = exports.splitMark = exports.tryMergeMarks = exports.isRemoveMark = exports.isDetach = exports.compareCellsFromSameRevision = exports.areOverlappingIdRanges = exports.isNoopMark = exports.isTombstone = exports.isImpactful = exports.settleMark = exports.areOutputCellsEmpty = exports.areInputCellsEmpty = exports.isImpactfulCellRename = exports.isDetachOfRemovedNodes = exports.isAttachAndDetachEffect = exports.markHasCellEffect = exports.markFillsCells = exports.markEmptiesCells = exports.getInputLength = exports.getOutputLength = exports.cloneCellId = exports.cloneMarkEffect = exports.cloneMark = exports.asAttachAndDetach = exports.normalizeCellRename = exports.getDetachedNodeId = exports.getDetachOutputCellId = exports.compareCellPositionsUsingTombstones = exports.CellOrder = exports.cellSourcesFromMarks = exports.getOutputCellId = exports.getInputCellId = exports.areEqualCellIds = exports.isActiveReattach = exports.isReattachEffect = exports.isReattach = exports.isAttach = exports.isInsert = exports.isRename = exports.isNewAttachEffect = exports.isNewAttach = exports.getNestedChanges = exports.createEmpty = exports.isEmpty = void 0;
-exports.getCrossFieldKeys = void 0;
+exports.getCrossFieldKeys = exports.withRevision = exports.withNodeChange = exports.omitMarkEffect = exports.extractMarkEffect = exports.splitMarkEffect = exports.splitMark = exports.tryMergeMarks = exports.areMergeableChangeAtoms = exports.isRemoveMark = exports.isPin = exports.isDetach = exports.compareCellsFromSameRevision = exports.areOverlappingIdRanges = exports.isNoopMark = exports.isTombstone = exports.isImpactful = exports.areOutputCellsEmpty = exports.areInputCellsEmpty = exports.markHasCellEffect = exports.markFillsCells = exports.markEmptiesCells = exports.getInputLength = exports.getOutputLength = exports.cloneCellId = exports.cloneMarkEffect = exports.cloneMark = exports.normalizeCellRename = exports.getMovedNodeId = exports.getDetachedRootId = exports.getAttachedRootId = exports.getDetachOutputCellId = exports.compareCellPositionsUsingTombstones = exports.CellOrder = exports.cellSourcesFromMarks = exports.getOutputCellId = exports.getInputCellId = exports.areEqualCellIds = exports.isActiveReattach = exports.isReattachEffect = exports.isReattach = exports.isAttach = exports.isInsert = exports.isRename = exports.isNewAttachEffect = exports.isNewAttach = exports.getNestedChanges = exports.createEmpty = exports.isEmpty = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../core/index.js");
 const index_js_2 = require("../../util/index.js");
@@ -27,22 +26,14 @@ exports.createEmpty = createEmpty;
 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,
-                !areInputCellsEmpty(mark) ? inputIndex : undefined /* inputIndex */,
-                !areOutputCellsEmpty(mark) ? outputIndex : undefined /* outputIndex */,
-            ]);
+            output.push([changes, inputIndex]);
         }
         if (!areInputCellsEmpty(mark)) {
             inputIndex += count;
         }
-        if (!areOutputCellsEmpty(mark)) {
-            outputIndex += count;
-        }
     }
     return output;
 }
@@ -52,10 +43,9 @@ function isNewAttach(mark, revision) {
 }
 exports.isNewAttach = isNewAttach;
 function isNewAttachEffect(effect, cellId, revision) {
-    return ((isAttach(effect) &&
+    return (isAttach(effect) &&
         cellId !== undefined &&
-        (effect.revision ?? revision) === (cellId.revision ?? revision)) ||
-        (isAttachAndDetachEffect(effect) && isNewAttachEffect(effect.attach, cellId, revision)));
+        (effect.revision ?? revision) === (cellId.revision ?? revision));
 }
 exports.isNewAttachEffect = isNewAttachEffect;
 function isRename(mark) {
@@ -67,7 +57,7 @@ function isInsert(mark) {
 }
 exports.isInsert = isInsert;
 function isAttach(effect) {
-    return effect.type === "Insert" || effect.type === "MoveIn";
+    return effect.type === "Insert";
 }
 exports.isAttach = isAttach;
 function isReattach(mark) {
@@ -91,16 +81,24 @@ function getInputCellId(mark) {
 }
 exports.getInputCellId = getInputCellId;
 function getOutputCellId(mark) {
-    if (isDetach(mark) || isRename(mark)) {
-        return getDetachOutputCellId(mark);
-    }
-    else if (markFillsCells(mark)) {
-        return undefined;
-    }
-    else if (isAttachAndDetachEffect(mark)) {
-        return getDetachOutputCellId(mark.detach);
+    const type = mark.type;
+    switch (type) {
+        case types_js_1.NoopMarkType: {
+            return getInputCellId(mark);
+        }
+        case "Insert": {
+            return undefined;
+        }
+        case "Remove": {
+            return getDetachOutputCellId(mark);
+        }
+        case "Rename": {
+            return mark.idOverride;
+        }
+        default: {
+            (0, internal_1.unreachableCase)(type);
+        }
     }
-    return getInputCellId(mark);
 }
 exports.getOutputCellId = getOutputCellId;
 function cellSourcesFromMarks(marks, contextGetter) {
@@ -153,9 +151,9 @@ function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, oldChange
         // 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.
-        (0, internal_1.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.
+        (0, internal_1.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.
@@ -185,42 +183,33 @@ function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, oldChange
         (0, internal_1.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 oldCellRevisionIndex = metadata.getIndex(oldMarkCell.revision);
-        const newCellRevisionIndex = metadata.getIndex(newMarkCell.revision);
+        const revisionComparison = metadata.compareRevisions(oldMarkCell.revision, newMarkCell.revision);
         // If the metadata defines an ordering for the revisions then the cell from the newer revision comes first.
-        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.
-            (0, internal_1.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;
+        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.
+        (0, internal_1.assert)(false, 0x8a2 /* Invalid cell ordering scenario */);
     }
 }
 exports.compareCellPositionsUsingTombstones = compareCellPositionsUsingTombstones;
@@ -228,99 +217,50 @@ exports.compareCellPositionsUsingTombstones = compareCellPositionsUsingTombstone
  * Gets the ID of the cell in the output context of the given detach `mark`.
  */
 function getDetachOutputCellId(mark) {
-    if (isRename(mark)) {
-        return mark.idOverride;
+    if (mark.cellRename !== undefined) {
+        return mark.cellRename;
     }
-    if (mark.idOverride !== undefined) {
-        return mark.idOverride;
+    if (mark.detachCellId !== undefined) {
+        return mark.detachCellId;
     }
-    return mark.revision === undefined
-        ? { localId: mark.id }
-        : { revision: mark.revision, localId: mark.id };
+    return getDetachedRootId(mark);
 }
 exports.getDetachOutputCellId = getDetachOutputCellId;
+/**
+ * Gets the ID of the node to be attached in the input context of the given detach `mark`.
+ */
+function getAttachedRootId(mark) {
+    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
+}
+exports.getAttachedRootId = getAttachedRootId;
 /**
  * Gets the ID of the detached node in the output context of the given detach `mark`.
  */
-function getDetachedNodeId(mark) {
-    switch (mark.type) {
-        case "Rename":
-        case "Remove": {
-            return getDetachOutputCellId(mark);
-        }
-        case "MoveOut": {
-            return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
-        }
-        default:
-            (0, internal_1.unreachableCase)(mark);
-    }
+function getDetachedRootId(mark) {
+    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
+}
+exports.getDetachedRootId = getDetachedRootId;
+function getMovedNodeId(mark) {
+    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
 }
-exports.getDetachedNodeId = getDetachedNodeId;
+exports.getMovedNodeId = getMovedNodeId;
 /**
  * Preserves the semantics of the given `mark` but repackages it into a `DetachOfRemovedNodes` when possible.
  */
 function normalizeCellRename(cellId, count, attach, detach) {
-    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,
-        };
-    }
+    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: "AttachAndDetach",
-        attach,
-        detach,
+        type: "Rename",
         count,
         cellId,
+        idOverride: outputId,
     };
 }
 exports.normalizeCellRename = normalizeCellRename;
-/**
- * Preserves the semantics of the given `mark` but repackages it into an `AttachAndDetach` mark if it is not already one.
- */
-function asAttachAndDetach(mark) {
-    if (mark.type === "AttachAndDetach") {
-        return mark;
-    }
-    const { cellId, count, changes, revision, ...effect } = mark;
-    const attachAndDetach = {
-        type: "AttachAndDetach",
-        count,
-        cellId,
-        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;
-}
-exports.asAttachAndDetach = asAttachAndDetach;
 function cloneMark(mark) {
     const clone = { ...cloneMarkEffect(mark), count: mark.count };
     if (mark.cellId !== undefined) {
@@ -331,10 +271,6 @@ function cloneMark(mark) {
 exports.cloneMark = cloneMark;
 function cloneMarkEffect(effect) {
     const clone = { ...effect };
-    if (clone.type === "AttachAndDetach") {
-        clone.attach = cloneMarkEffect(clone.attach);
-        clone.detach = cloneMarkEffect(clone.detach);
-    }
     return clone;
 }
 exports.cloneMarkEffect = cloneMarkEffect;
@@ -373,18 +309,6 @@ function markHasCellEffect(mark) {
     return areInputCellsEmpty(mark) !== areOutputCellsEmpty(mark);
 }
 exports.markHasCellEffect = markHasCellEffect;
-function isAttachAndDetachEffect(effect) {
-    return effect.type === "AttachAndDetach";
-}
-exports.isAttachAndDetachEffect = isAttachAndDetachEffect;
-function isDetachOfRemovedNodes(mark) {
-    return isDetach(mark) && mark.cellId !== undefined;
-}
-exports.isDetachOfRemovedNodes = isDetachOfRemovedNodes;
-function isImpactfulCellRename(mark) {
-    return (isAttachAndDetachEffect(mark) || isDetachOfRemovedNodes(mark)) && isImpactful(mark);
-}
-exports.isImpactfulCellRename = isImpactfulCellRename;
 function areInputCellsEmpty(mark) {
     return mark.cellId !== undefined;
 }
@@ -392,35 +316,22 @@ exports.areInputCellsEmpty = areInputCellsEmpty;
 function areOutputCellsEmpty(mark) {
     const type = mark.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return mark.cellId !== undefined;
+        }
         case "Remove":
-        case "Rename":
-        case "MoveOut":
-        case "AttachAndDetach":
+        case "Rename": {
             return true;
-        case "MoveIn":
-        case "Insert":
+        }
+        case "Insert": {
             return false;
-        default:
+        }
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.areOutputCellsEmpty = areOutputCellsEmpty;
-/**
- * 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.
- */
-function settleMark(mark) {
-    if (isImpactful(mark)) {
-        return mark;
-    }
-    return omitMarkEffect(mark);
-}
-exports.settleMark = settleMark;
 /**
  * Returns true if and only iff the given `mark` would have impact on the field when applied.
  *
@@ -431,10 +342,12 @@ exports.settleMark = settleMark;
 function isImpactful(mark) {
     const type = mark.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return false;
-        case "Rename":
+        }
+        case "Rename": {
             return true;
+        }
         case "Remove": {
             const inputId = getInputCellId(mark);
             if (inputId === undefined) {
@@ -444,18 +357,13 @@ function isImpactful(mark) {
             (0, internal_1.assert)(outputId !== undefined, 0x824 /* Remove marks must have an output cell ID */);
             return !(0, index_js_1.areEqualChangeAtomIds)(inputId, outputId);
         }
-        case "AttachAndDetach":
-        case "MoveOut":
-            return true;
-        case "MoveIn":
-            // MoveIn marks always target an empty cell.
-            (0, internal_1.assert)(mark.cellId !== undefined, 0x825 /* MoveIn marks should target empty cells */);
-            return true;
-        case "Insert":
+        case "Insert": {
             // A Revive has no impact if the nodes are already in the document.
             return mark.cellId !== undefined;
-        default:
+        }
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.isImpactful = isImpactful;
@@ -483,9 +391,13 @@ function compareCellsFromSameRevision(cell1, count1, cell2, count2) {
 exports.compareCellsFromSameRevision = compareCellsFromSameRevision;
 function isDetach(mark) {
     const type = mark?.type;
-    return type === "Remove" || type === "MoveOut";
+    return type === "Remove";
 }
 exports.isDetach = isDetach;
+function isPin(mark) {
+    return mark?.type === "Insert" && mark.cellId === undefined;
+}
+exports.isPin = isPin;
 function isRemoveMark(mark) {
     return mark?.type === "Remove";
 }
@@ -494,17 +406,10 @@ function areMergeableChangeAtoms(lhs, lhsCount, rhs) {
     if (lhs === undefined || rhs === undefined) {
         return lhs === undefined && rhs === undefined;
     }
-    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);
+    return (lhs.revision === rhs.revision &&
+        (0, index_js_2.areAdjacentIntegerRanges)(lhs.localId, lhsCount, rhs.localId));
 }
+exports.areMergeableChangeAtoms = areMergeableChangeAtoms;
 function areMergeableCellIds(lhs, lhsCount, rhs) {
     return areMergeableChangeAtoms(lhs, lhsCount, rhs);
 }
@@ -539,65 +444,43 @@ function tryMergeEffects(lhs, rhs, lhsCount) {
     if (rhs.type === types_js_1.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;
-        }
-        (0, internal_1.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) && !haveMergeableIdOverrides(lhs, lhsCount, rhs)) {
+    if (isDetach(lhs) &&
+        isDetach(rhs) &&
+        !areMergeableChangeAtoms(lhs.cellRename, lhsCount, rhs.cellRename)) {
         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 &&
-                haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
+                areMergeableChangeAtoms(lhsDetach.cellRename, lhsCount, rhs.cellRename) &&
+                areMergeableChangeAtoms(lhsDetach.detachCellId, lhsCount, rhs.detachCellId)) {
                 return lhsDetach;
             }
             break;
         }
         case "Rename": {
             const lhsDetach = lhs;
-            if (haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
+            if (areMergeableChangeAtoms(lhsDetach.idOverride, lhsCount, rhs.idOverride)) {
                 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) {
+            if (lhsInsert.id + lhsCount === rhs.id &&
+                areMergeableChangeAtoms(lhsInsert.detachCellId, lhsCount, rhs.detachCellId)) {
                 return lhsInsert;
             }
             break;
         }
-        default:
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
     return undefined;
 }
@@ -631,8 +514,9 @@ exports.splitMark = splitMark;
 function splitMarkEffect(effect, length) {
     const type = effect.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return [effect, effect];
+        }
         case "Insert": {
             const effect1 = {
                 ...effect,
@@ -641,23 +525,21 @@ function splitMarkEffect(effect, length) {
                 ...effect,
                 id: effect.id + 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);
+            if (effect.detachCellId !== undefined) {
+                effect2.detachCellId = splitDetachEvent(effect.detachCellId, length);
             }
-            return [effect, effect2];
+            return [effect1, effect2];
         }
         case "Remove": {
             const effect1 = { ...effect };
             const id2 = (0, index_js_2.brand)(effect.id + length);
             const effect2 = { ...effect, id: id2 };
             const effect2Remove = effect2;
-            if (effect2Remove.idOverride !== undefined) {
-                effect2Remove.idOverride = splitDetachEvent(effect2Remove.idOverride, length);
+            if (effect2Remove.cellRename !== undefined) {
+                effect2Remove.cellRename = splitDetachEvent(effect2Remove.cellRename, length);
+            }
+            if (effect2Remove.detachCellId !== undefined) {
+                effect2Remove.detachCellId = splitDetachEvent(effect2Remove.detachCellId, length);
             }
             return [effect1, effect2];
         }
@@ -670,37 +552,9 @@ function splitMarkEffect(effect, length) {
             }
             return [effect1, effect2];
         }
-        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:
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.splitMarkEffect = splitMarkEffect;
@@ -728,11 +582,11 @@ function omitMarkEffect(mark) {
 exports.omitMarkEffect = omitMarkEffect;
 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;
 }
@@ -755,78 +609,54 @@ function addRevision(effect, revision) {
     if (effect.type === types_js_1.NoopMarkType || isRename(effect)) {
         return;
     }
-    if (effect.type === "AttachAndDetach") {
-        addRevision(effect.attach, revision);
-        addRevision(effect.detach, revision);
-        return;
-    }
     (0, internal_1.assert)(effect.revision === undefined || effect.revision === revision, 0x829 /* Should not overwrite mark revision */);
     effect.revision = revision;
 }
-function getEndpoint(effect) {
-    return effect.finalEndpoint ?? { revision: effect.revision, localId: effect.id };
-}
-exports.getEndpoint = getEndpoint;
 function getCrossFieldKeys(change) {
     const keys = [];
     for (const mark of change) {
-        keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
+        keys.push(...getCrossFieldKeysForMark(mark, mark.count));
     }
     return keys;
 }
 exports.getCrossFieldKeys = getCrossFieldKeys;
-function getCrossFieldKeysForMarkEffect(effect, count) {
-    switch (effect.type) {
-        case "Insert":
-            // 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: index_js_3.CrossFieldTarget.Source,
-                        revision: effect.revision,
-                        localId: effect.id,
-                    },
-                    count,
-                },
+function getCrossFieldKeysForMark(mark, count) {
+    switch (mark.type) {
+        case "Insert": {
+            const keys = [
                 {
                     key: {
+                        revision: mark.revision,
+                        localId: mark.id,
                         target: index_js_3.CrossFieldTarget.Destination,
-                        revision: effect.revision,
-                        localId: effect.id,
                     },
                     count,
                 },
             ];
-        case "MoveOut":
-            return [
-                {
-                    key: {
-                        target: index_js_3.CrossFieldTarget.Source,
-                        revision: effect.revision,
-                        localId: effect.id,
-                    },
+            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: index_js_3.CrossFieldTarget.Source },
                     count,
-                },
-            ];
-        case "MoveIn":
+                });
+            }
+            return keys;
+        }
+        case "Remove": {
             return [
                 {
                     key: {
-                        target: index_js_3.CrossFieldTarget.Destination,
-                        revision: effect.revision,
-                        localId: effect.id,
+                        revision: mark.revision,
+                        localId: mark.id,
+                        target: index_js_3.CrossFieldTarget.Source,
                     },
                     count,
                 },
             ];
-        case "AttachAndDetach":
-            return [
-                ...getCrossFieldKeysForMarkEffect(effect.attach, count),
-                ...getCrossFieldKeysForMarkEffect(effect.detach, count),
-            ];
-        default:
+        }
+        default: {
             return [];
+        }
     }
 }
 //# sourceMappingURL=utils.js.map