@fluidframework/tree 2.74.0 → 2.81.0-374083

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

@@ -4,90 +4,16 @@
  */
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { DiscriminatedUnionDispatcher, } from "../../codec/index.js";
+import { areEqualChangeAtomIds, } from "../../core/index.js";
 import { brand } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 import { EncodedNodeChangeset, } from "../modular-schema/index.js";
 import { Changeset as ChangesetSchema } from "./formatV2.js";
 import { NoopMarkType, } from "./types.js";
-import { isNoopMark, normalizeCellRename } from "./utils.js";
+import { getAttachedRootId, getDetachedRootId, isNoopMark, splitMark } from "./utils.js";
+import { getFromChangeAtomIdMap, rangeQueryChangeAtomIdMap } from "../changeAtomIdBTree.js";
 export function makeV2CodecHelpers(revisionTagCodec) {
     const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
-    const markEffectCodec = {
-        encode(effect, context) {
-            function encodeRevision(revision) {
-                if (revision === undefined || revision === context.revision) {
-                    return undefined;
-                }
-                return revisionTagCodec.encode(revision, context);
-            }
-            const type = effect.type;
-            switch (type) {
-                case "MoveIn":
-                    return {
-                        moveIn: {
-                            revision: encodeRevision(effect.revision),
-                            finalEndpoint: effect.finalEndpoint === undefined
-                                ? undefined
-                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
-                            id: effect.id,
-                        },
-                    };
-                case "Insert":
-                    return {
-                        insert: {
-                            revision: encodeRevision(effect.revision),
-                            id: effect.id,
-                        },
-                    };
-                case "Remove":
-                    return {
-                        remove: {
-                            revision: encodeRevision(effect.revision),
-                            idOverride: effect.idOverride === undefined
-                                ? undefined
-                                : changeAtomIdCodec.encode(effect.idOverride, context),
-                            id: effect.id,
-                        },
-                    };
-                case "MoveOut":
-                    return {
-                        moveOut: {
-                            revision: encodeRevision(effect.revision),
-                            finalEndpoint: effect.finalEndpoint === undefined
-                                ? undefined
-                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
-                            idOverride: effect.idOverride === undefined
-                                ? undefined
-                                : changeAtomIdCodec.encode(effect.idOverride, context),
-                            id: effect.id,
-                        },
-                    };
-                case "AttachAndDetach":
-                    return {
-                        attachAndDetach: {
-                            attach: markEffectCodec.encode(effect.attach, context),
-                            detach: markEffectCodec.encode(effect.detach, context),
-                        },
-                    };
-                case "Rename":
-                    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-                    // renames are encoded as AttachAndDetach with a special id.
-                    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-                    return markEffectCodec.encode({
-                        type: "AttachAndDetach",
-                        attach: { type: "MoveIn", id: renameLocalId },
-                        detach: { type: "MoveOut", id: renameLocalId, idOverride: effect.idOverride },
-                    }, context);
-                case NoopMarkType:
-                    fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
-                default:
-                    unreachableCase(type);
-            }
-        },
-        decode(encoded, context) {
-            return decoderDispatcher.dispatch(encoded, context);
-        },
-    };
     function decodeRevision(encodedRevision, context) {
         if (encodedRevision === undefined) {
             assert(context.revision !== undefined, 0x996 /* Implicit revision should be provided */);
@@ -95,138 +21,394 @@ export function makeV2CodecHelpers(revisionTagCodec) {
         }
         return revisionTagCodec.decode(encodedRevision, context);
     }
-    const decoderLibrary = {
-        moveIn(encoded, context) {
-            const { id, finalEndpoint, revision } = encoded;
-            const mark = {
-                type: "MoveIn",
-                id,
-            };
-            mark.revision = decodeRevision(revision, context);
-            if (finalEndpoint !== undefined) {
-                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+    const decoderLibrary = makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision);
+    const decoderDispatcher = new DiscriminatedUnionDispatcher(decoderLibrary);
+    return {
+        changeAtomIdCodec,
+        decoderLibrary,
+        encodeMarkEffect(mark, context) {
+            return encodeMarkEffectV2(mark, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec);
+        },
+        decodeRevision: (encoded, context) => encoded === undefined
+            ? (context.revision ?? fail("Expected a default revision"))
+            : revisionTagCodec.decode(encoded, context),
+        decodeMarkEffect: (encoded, count, cellId, context) => {
+            return decoderDispatcher.dispatch(encoded, count, cellId, context);
+        },
+    };
+}
+export function decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect) {
+    const marks = [];
+    for (const mark of changeset) {
+        const decodedMark = {
+            count: mark.count,
+        };
+        if (mark.cellId !== undefined) {
+            decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
+        }
+        if (mark.effect !== undefined) {
+            Object.assign(decodedMark, decodeMarkEffect(mark.effect, mark.count, decodedMark.cellId, context));
+        }
+        if (mark.changes !== undefined) {
+            if (decodedMark.cellId === undefined) {
+                decodedMark.changes = context.decodeNode(mark.changes);
             }
-            return mark;
+            else {
+                context.decodeRootNodeChange(decodedMark.cellId, mark.changes);
+            }
+        }
+        marks.push(decodedMark);
+    }
+    return marks;
+}
+function makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision) {
+    function decodeMoveIn(encoded, context) {
+        const { id, revision } = encoded;
+        const endpoint = encoded.finalEndpoint === undefined
+            ? undefined
+            : changeAtomIdCodec.decode(encoded.finalEndpoint, context.baseContext);
+        const mark = {
+            type: "Insert",
+            id: endpoint?.localId ?? id,
+            revision: endpoint?.revision ?? decodeRevision(revision, context.baseContext),
+        };
+        return mark;
+    }
+    const decoderLibrary = {
+        moveIn(encoded, count, cellId, context) {
+            return decodeMoveIn(encoded, context);
         },
-        insert(encoded, context) {
+        insert(encoded, count, cellId, context) {
             const { id, revision } = encoded;
             const mark = {
                 type: "Insert",
                 id,
             };
-            mark.revision = decodeRevision(revision, context);
+            mark.revision = decodeRevision(revision, context.baseContext);
+            const attachId = getAttachedRootId(mark);
+            if (cellId !== undefined && !areEqualChangeAtomIds(cellId, attachId)) {
+                context.decodeRootRename(cellId, attachId, count);
+            }
             return mark;
         },
-        remove(encoded, context) {
+        remove(encoded, count, cellId, context) {
             const { id, revision, idOverride } = encoded;
-            const mark = {
-                type: "Remove",
-                id,
-            };
-            mark.revision = decodeRevision(revision, context);
-            if (idOverride !== undefined) {
-                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
-            }
-            return mark;
+            const cellRename = idOverride === undefined
+                ? undefined
+                : changeAtomIdCodec.decode(idOverride, context.baseContext);
+            return decodeDetach(cellId, count, decodeRevision(revision, context.baseContext), id, cellRename, undefined, context);
         },
-        moveOut(encoded, context) {
-            const { id, finalEndpoint, idOverride, revision } = encoded;
-            const mark = {
-                type: "MoveOut",
-                id,
-            };
-            mark.revision = decodeRevision(revision, context);
+        moveOut(encoded, count, cellId, context) {
+            const { id, idOverride, revision, finalEndpoint } = encoded;
+            const cellRename = idOverride === undefined
+                ? undefined
+                : changeAtomIdCodec.decode(idOverride, context.baseContext);
+            const decodedRevision = decodeRevision(revision, context.baseContext);
             if (finalEndpoint !== undefined) {
-                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+                const decodedEndpoint = changeAtomIdCodec.decode(finalEndpoint, context.baseContext);
+                return decodeDetach(cellId, count, decodedEndpoint.revision ?? fail("Revision should be defined"), decodedEndpoint.localId, cellRename, { revision: decodedRevision, localId: id }, context);
             }
-            if (idOverride !== undefined) {
-                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
-            }
-            return mark;
+            return decodeDetach(cellId, count, decodedRevision, id, cellRename, undefined, context);
         },
-        attachAndDetach(encoded, context) {
-            const attach = decoderDispatcher.dispatch(encoded.attach, context);
-            const detach = decoderDispatcher.dispatch(encoded.detach, context);
+        attachAndDetach(encoded, count, cellId, context) {
             // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
             // renames are encoded as AttachAndDetach with a special id.
             // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-            if (attach.id === renameLocalId) {
-                assert(detach.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
+            const encodedRenameId = tryGetEncodedCellRenameFromAttachAndDetach(encoded);
+            if (encodedRenameId !== undefined) {
                 return {
                     type: "Rename",
-                    idOverride: detach.idOverride,
+                    idOverride: changeAtomIdCodec.decode(encodedRenameId, context.baseContext),
                 };
             }
+            assert(encoded.detach.remove !== undefined, "Attach and detach should always contains a remove");
+            const detachId = encoded.detach.remove.idOverride === undefined
+                ? {
+                    revision: decodeRevision(encoded.detach.remove.revision, context.baseContext),
+                    localId: encoded.detach.remove.id,
+                }
+                : changeAtomIdCodec.decode(encoded.detach.remove.idOverride, context.baseContext);
+            assert(cellId !== undefined, "Attach and detach should target an empty cell");
+            if (encoded.attach.moveIn === undefined) {
+                context.decodeRootRename(cellId, detachId, count);
+            }
+            else {
+                context.decodeMoveAndDetach(detachId, count);
+            }
             return {
-                type: "AttachAndDetach",
-                attach,
-                detach,
+                type: "Rename",
+                idOverride: detachId,
             };
         },
     };
-    const decoderDispatcher = new DiscriminatedUnionDispatcher(decoderLibrary);
-    return {
-        changeAtomIdCodec,
-        markEffectCodec,
-        decoderLibrary,
-        decodeRevision,
+    return decoderLibrary;
+}
+function decodeDetach(cellId, count, revision, localId, cellRename, detachCellId, context) {
+    const detachId = { revision, localId };
+    if (cellId !== undefined) {
+        context.decodeRootRename(cellId, detachId, count);
+        return {
+            type: "Rename",
+            idOverride: cellRename ?? detachId,
+        };
+    }
+    const mark = {
+        type: "Remove",
+        revision,
+        id: localId,
     };
+    if (cellRename !== undefined) {
+        mark.cellRename = cellRename;
+    }
+    if (detachCellId !== undefined) {
+        mark.detachCellId = detachCellId;
+    }
+    return mark;
 }
 export function makeV2Codec(revisionTagCodec) {
-    const { markEffectCodec, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
+    const { decodeMarkEffect, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
     return {
-        encode: (changeset, context) => {
-            const jsonMarks = [];
-            for (const mark of changeset) {
-                const encodedMark = {
-                    count: mark.count,
-                };
-                if (!isNoopMark(mark)) {
-                    encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
-                }
-                if (mark.cellId !== undefined) {
-                    encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
-                }
-                if (mark.changes !== undefined) {
-                    encodedMark.changes = context.encodeNode(mark.changes);
-                }
-                jsonMarks.push(encodedMark);
-            }
-            return jsonMarks;
+        encode: (changeset, context) => encodeSequenceChangeset(changeset, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec, encodeMarkEffectV2),
+        decode: (changeset, context) => decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect),
+        encodedSchema: ChangesetSchema(EncodedNodeChangeset),
+    };
+}
+export function encodeSequenceChangeset(changeset, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
+    const jsonMarks = [];
+    for (const mark of changeset) {
+        jsonMarks.push(...encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect));
+    }
+    return jsonMarks;
+}
+function encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
+    const splitLength = getLengthToSplitMark(mark, context);
+    if (splitLength < mark.count) {
+        const [mark1, mark2] = splitMark(mark, splitLength);
+        return [
+            encodeSplitMark(mark1, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
+            ...encodeMark(mark2, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
+        ];
+    }
+    return [encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect)];
+}
+function encodeRename(mark, context, changeAtomIdCodec, encodeRevision) {
+    assert(mark.cellId !== undefined, "Rename should target empty cell");
+    const inputDetachId = context.getInputRootId(mark.idOverride, mark.count).value;
+    const isMoveInAndDetach = !context.isAttachId(mark.idOverride, mark.count).value &&
+        (context.isDetachId(mark.idOverride, mark.count).value ||
+            (inputDetachId !== undefined && !areEqualChangeAtomIds(inputDetachId, mark.cellId)));
+    if (isMoveInAndDetach) {
+        // These cells are the final detach location of moved nodes.
+        const encodedRevision = encodeRevision(mark.idOverride.revision);
+        // XXX: Use finalEndpoint if there is an associated cellDetachId.
+        return {
+            attachAndDetach: {
+                attach: {
+                    moveIn: {
+                        revision: encodedRevision,
+                        id: mark.idOverride.localId,
+                    },
+                },
+                detach: {
+                    remove: {
+                        revision: encodedRevision,
+                        id: mark.idOverride.localId,
+                    },
+                },
+            },
+        };
+    }
+    const renamedRootId = context.rootRenames.getFirst(mark.cellId, mark.count).value;
+    const outputRootId = renamedRootId ?? mark.cellId;
+    const isMoveOutAndAttach = context.isAttachId(outputRootId, mark.count).value;
+    const isMoveOutAndDetach = renamedRootId !== undefined && !areEqualChangeAtomIds(renamedRootId, mark.idOverride);
+    if (isMoveOutAndAttach || isMoveOutAndDetach) {
+        // Detached nodes which were last at this cell location have been moved.
+        // XXX: mark.idOverride represents detachCellId, so we should represent it using the moveOut's ID and use outputRootId as the finalDetachId.
+        // Is that always true?
+        return {
+            moveOut: {
+                revision: encodeRevision(outputRootId.revision),
+                id: outputRootId.localId,
+                idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
+            },
+        };
+    }
+    if (renamedRootId !== undefined) {
+        return {
+            remove: {
+                revision: encodeRevision(outputRootId.revision),
+                id: outputRootId.localId,
+            },
+        };
+    }
+    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
+    // renames are encoded as AttachAndDetach with a special id.
+    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+    return {
+        attachAndDetach: {
+            attach: { insert: { id: renameLocalId } },
+            detach: {
+                remove: {
+                    id: renameLocalId,
+                    idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
+                },
+            },
         },
-        decode: (changeset, context) => {
-            const marks = [];
-            for (const mark of changeset) {
-                const decodedMark = {
-                    count: mark.count,
-                };
-                if (mark.effect !== undefined) {
-                    Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
-                }
-                if (mark.cellId !== undefined) {
-                    decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
-                }
-                // Type deduction wrongly narrows the type of `decodedMark` to `NoopMark & HasMarkFields`.
-                // We declare a new casted copy of `decodedMark` to recover the correct type.
-                let decodedMark2 = decodedMark;
-                if (decodedMark2.cellId !== undefined && decodedMark2.type === "AttachAndDetach") {
-                    // In documents generated by clients on release <=2.1 (i.e., not running the code from the PR that added this comment),
-                    // rename-like AttachAndDetach marks are not normalized to Rename marks thus requiring this normalization step.
-                    // This ensures backward compatibility with documents generated by clients on release <=2.1.
-                    decodedMark2 = normalizeCellRename(decodedMark2.cellId, decodedMark2.count, decodedMark2.attach, decodedMark2.detach);
-                }
-                if (mark.changes !== undefined) {
-                    decodedMark2.changes = context.decodeNode(mark.changes);
+    };
+}
+function getLengthToSplitMark(mark, context) {
+    let count = mark.cellId === undefined
+        ? mark.count
+        : rangeQueryChangeAtomIdMap(context.rootNodeChanges, mark.cellId, mark.count).length;
+    if (mark.cellId !== undefined) {
+        count = context.getInputRootId(mark.cellId, count).length;
+    }
+    switch (mark.type) {
+        case "Insert": {
+            count = context.isDetachId(getAttachedRootId(mark), count).length;
+            break;
+        }
+        case "Remove": {
+            count = context.isAttachId(getDetachedRootId(mark), count).length;
+            break;
+        }
+        case "Rename": {
+            count = context.getInputRootId(mark.idOverride, count).length;
+            count = context.isAttachId(mark.idOverride, count).length;
+            count = context.isDetachId(mark.idOverride, count).length;
+            const cellId = mark.cellId ?? fail("Rename should have cell ID");
+            const renameEntry = context.rootRenames.getFirst(cellId, count);
+            count = renameEntry.length;
+            count = context.isAttachId(renameEntry.value ?? cellId, count).length;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return count;
+}
+function encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
+    const encodedMark = {
+        count: mark.count,
+    };
+    if (!isNoopMark(mark)) {
+        encodedMark.effect = encodeMarkEffect(mark, context, encodeRevision, changeAtomIdCodec);
+    }
+    if (mark.cellId !== undefined) {
+        assert(mark.changes === undefined, "Empty cells should not have node changes");
+        encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
+        const nodeId = getFromChangeAtomIdMap(context.rootNodeChanges, mark.cellId);
+        if (nodeId !== undefined) {
+            encodedMark.changes = context.encodeNode(nodeId);
+        }
+    }
+    else if (mark.changes !== undefined) {
+        encodedMark.changes = context.encodeNode(mark.changes);
+    }
+    return encodedMark;
+}
+function encodeMarkEffectV2(mark, context, encodeRevision, changeAtomIdCodec) {
+    const type = mark.type;
+    switch (type) {
+        case "Insert": {
+            const attachId = getAttachedRootId(mark);
+            const isMove = context.isDetachId(attachId, 1).value;
+            // If the input context ID for these nodes is not the cell ID,
+            // then these nodes are being moved from the location at which they were last detached.
+            const inputId = context.getInputRootId(attachId, mark.count).value ?? attachId;
+            const isInitialAttachLocation = mark.cellId === undefined || areEqualChangeAtomIds(mark.cellId, inputId);
+            return isMove || !isInitialAttachLocation
+                ? {
+                    moveIn: { revision: encodeRevision(mark.revision), id: mark.id },
                 }
-                marks.push(decodedMark2);
+                : {
+                    insert: {
+                        revision: encodeRevision(mark.revision),
+                        id: mark.id,
+                    },
+                };
+        }
+        case "Remove": {
+            const encodedIdOverride = mark.cellRename === undefined
+                ? undefined
+                : changeAtomIdCodec.encode(mark.cellRename, context.baseContext);
+            const detachId = getDetachedRootId(mark);
+            const isMove = context.isAttachId(detachId, 1).value;
+            const outputCellId = mark.cellRename ?? mark.detachCellId ?? detachId;
+            // If the final detach location for the nodes were here,
+            // then the output cell ID would be the same as the detach ID.
+            // So if the cell ID is different from the detach ID, the nodes must have been moved.
+            const isFinalDetachLocation = areEqualChangeAtomIds(detachId, outputCellId);
+            const isMoveOrDetachedMove = isMove || !isFinalDetachLocation;
+            if (mark.detachCellId !== undefined) {
+                assert(isMoveOrDetachedMove, "Only detaches representing a move out should specify a detach cell ID");
+                // XXX: Set final endpoint on the move in.
+                return {
+                    moveOut: {
+                        revision: encodeRevision(mark.detachCellId.revision),
+                        id: mark.detachCellId.localId,
+                        idOverride: encodedIdOverride,
+                        finalEndpoint: changeAtomIdCodec.encode({ revision: mark.revision, localId: mark.id }, context.baseContext),
+                    },
+                };
             }
-            return marks;
-        },
-        encodedSchema: ChangesetSchema(EncodedNodeChangeset),
-    };
+            const encodedRevision = encodeRevision(mark.revision);
+            return isMoveOrDetachedMove
+                ? {
+                    moveOut: {
+                        revision: encodedRevision,
+                        id: mark.id,
+                        idOverride: encodedIdOverride,
+                    },
+                }
+                : {
+                    remove: {
+                        revision: encodedRevision,
+                        idOverride: encodedIdOverride,
+                        id: mark.id,
+                    },
+                };
+        }
+        case "Rename": {
+            return encodeRename(mark, context, changeAtomIdCodec, encodeRevision);
+        }
+        case NoopMarkType: {
+            fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
+        }
+        default: {
+            unreachableCase(type);
+        }
+    }
+}
+export function encodeRevisionWithContext(revision, context, revisionTagCodec) {
+    return revision === undefined || revision === context.revision
+        ? undefined
+        : revisionTagCodec.encode(revision, context);
 }
 /**
  * Arbitrary ID that is used to indicate a Rename effect.
  */
 const renameLocalId = brand(-1);
+/**
+ * If the encoded mark effect represents a simple cell rename (with no effect on root nodes),
+ * returns the encoded form of the ID the cell is being renamed to,
+ * and otherwise returns undefined.
+ */
+export function tryGetEncodedCellRename(encoded) {
+    const attachAndDetach = encoded.attachAndDetach;
+    if (attachAndDetach === undefined) {
+        return undefined;
+    }
+}
+function tryGetEncodedCellRenameFromAttachAndDetach(encoded) {
+    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
+    // renames are encoded as AttachAndDetach with a special id.
+    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+    if (encoded.attach.insert?.id === renameLocalId) {
+        assert(encoded.detach.remove?.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
+        return encoded.detach.remove.idOverride;
+    }
+}
 //# sourceMappingURL=sequenceFieldCodecV2.js.map