@fluidframework/tree 2.80.0 → 2.81.0-374083

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 { brand } from "../../util/index.js";
+import { areAdjacentIntegerRanges, brand } from "../../util/index.js";
 import { CrossFieldTarget, } from "../modular-schema/index.js";
 import { NoopMarkType, } from "./types.js";
 export function isEmpty(change) {
@@ -21,22 +21,14 @@ 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,
-                areInputCellsEmpty(mark) ? undefined : inputIndex /* inputIndex */,
-                areOutputCellsEmpty(mark) ? undefined : outputIndex /* outputIndex */,
-            ]);
+            output.push([changes, inputIndex]);
         }
         if (!areInputCellsEmpty(mark)) {
             inputIndex += count;
         }
-        if (!areOutputCellsEmpty(mark)) {
-            outputIndex += count;
-        }
     }
     return output;
 }
@@ -44,10 +36,9 @@ 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)) ||
-        (isAttachAndDetachEffect(effect) && isNewAttachEffect(effect.attach, cellId, revision)));
+        (effect.revision ?? revision) === (cellId.revision ?? revision));
 }
 export function isRename(mark) {
     return mark.type === "Rename";
@@ -56,7 +47,7 @@ export function isInsert(mark) {
     return mark.type === "Insert";
 }
 export function isAttach(effect) {
-    return effect.type === "Insert" || effect.type === "MoveIn";
+    return effect.type === "Insert";
 }
 export function isReattach(mark) {
     return isReattachEffect(mark, mark.cellId);
@@ -74,16 +65,24 @@ export function getInputCellId(mark) {
     return mark.cellId;
 }
 export 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 NoopMarkType: {
+            return getInputCellId(mark);
+        }
+        case "Insert": {
+            return undefined;
+        }
+        case "Remove": {
+            return getDetachOutputCellId(mark);
+        }
+        case "Rename": {
+            return mark.idOverride;
+        }
+        default: {
+            unreachableCase(type);
+        }
     }
-    return getInputCellId(mark);
 }
 export function cellSourcesFromMarks(marks, contextGetter) {
     const set = new Set();
@@ -166,138 +165,78 @@ 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 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.
-            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.
+        assert(false, 0x8a2 /* Invalid cell ordering scenario */);
     }
 }
 /**
  * Gets the ID of the cell in the output context of the given detach `mark`.
  */
 export 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);
+}
+/**
+ * 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);
 }
 /**
  * Gets the ID of the detached node in the output context of the given detach `mark`.
  */
-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);
-        }
-    }
+export function getDetachedRootId(mark) {
+    return makeChangeAtomId(mark.id, mark.revision);
+}
+export function getMovedNodeId(mark) {
+    return makeChangeAtomId(mark.id, mark.revision);
 }
 /**
  * Preserves the semantics of the given `mark` but repackages it into a `DetachOfRemovedNodes` when possible.
  */
 export 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,
     };
 }
-/**
- * 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,
-        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 };
     if (mark.cellId !== undefined) {
@@ -307,10 +246,6 @@ 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) {
@@ -342,15 +277,6 @@ 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;
 }
@@ -361,12 +287,9 @@ export function areOutputCellsEmpty(mark) {
             return mark.cellId !== undefined;
         }
         case "Remove":
-        case "Rename":
-        case "MoveOut":
-        case "AttachAndDetach": {
+        case "Rename": {
             return true;
         }
-        case "MoveIn":
         case "Insert": {
             return false;
         }
@@ -375,19 +298,6 @@ export function areOutputCellsEmpty(mark) {
         }
     }
 }
-/**
- * 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.
  *
@@ -413,15 +323,6 @@ export function isImpactful(mark) {
             assert(outputId !== undefined, 0x824 /* Remove marks must have an output cell ID */);
             return !areEqualChangeAtomIds(inputId, outputId);
         }
-        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;
@@ -451,25 +352,20 @@ export function compareCellsFromSameRevision(cell1, count1, cell2, count2) {
 }
 export function isDetach(mark) {
     const type = mark?.type;
-    return type === "Remove" || type === "MoveOut";
+    return type === "Remove";
+}
+export function isPin(mark) {
+    return mark?.type === "Insert" && mark.cellId === undefined;
 }
 export function isRemoveMark(mark) {
     return mark?.type === "Remove";
 }
-function areMergeableChangeAtoms(lhs, lhsCount, rhs) {
+export 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 &&
+        areAdjacentIntegerRanges(lhs.localId, lhsCount, rhs.localId));
 }
 function areMergeableCellIds(lhs, lhsCount, rhs) {
     return areMergeableChangeAtoms(lhs, lhsCount, rhs);
@@ -504,59 +400,36 @@ 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) && !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;
@@ -607,23 +480,21 @@ export 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 = 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];
         }
@@ -636,35 +507,6 @@ export 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: {
             unreachableCase(type);
         }
@@ -717,78 +559,50 @@ 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(...getCrossFieldKeysForMarkEffect(mark, mark.count));
+        keys.push(...getCrossFieldKeysForMark(mark, mark.count));
     }
     return keys;
 }
-function getCrossFieldKeysForMarkEffect(effect, count) {
-    switch (effect.type) {
+function getCrossFieldKeysForMark(mark, count) {
+    switch (mark.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: CrossFieldTarget.Source,
-                        revision: effect.revision,
-                        localId: effect.id,
-                    },
-                    count,
-                },
+            const keys = [
                 {
                     key: {
+                        revision: mark.revision,
+                        localId: mark.id,
                         target: CrossFieldTarget.Destination,
-                        revision: effect.revision,
-                        localId: effect.id,
                     },
                     count,
                 },
             ];
-        }
-        case "MoveOut": {
-            return [
-                {
-                    key: {
-                        target: 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: CrossFieldTarget.Source },
                     count,
-                },
-            ];
+                });
+            }
+            return keys;
         }
-        case "MoveIn": {
+        case "Remove": {
             return [
                 {
                     key: {
-                        target: CrossFieldTarget.Destination,
-                        revision: effect.revision,
-                        localId: effect.id,
+                        revision: mark.revision,
+                        localId: mark.id,
+                        target: CrossFieldTarget.Source,
                     },
                     count,
                 },
             ];
         }
-        case "AttachAndDetach": {
-            return [
-                ...getCrossFieldKeysForMarkEffect(effect.attach, count),
-                ...getCrossFieldKeysForMarkEffect(effect.detach, count),
-            ];
-        }
         default: {
             return [];
         }