@fluidframework/tree 2.113.1 → 2.114.0

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

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeFieldId = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
+exports.normalizeFieldId = exports.getParentFieldId = exports.ModularEditBuilder = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const sorted_btree_es6_1 = require("@tylerbu/sorted-btree-es6");
@@ -13,10 +13,12 @@ const index_js_1 = require("../../codec/index.js");
 const index_js_2 = require("../../core/index.js");
 const index_js_3 = require("../../util/index.js");
 const changeAtomIdBTree_js_1 = require("../changeAtomIdBTree.js");
-const crossFieldQueries_js_1 = require("./crossFieldQueries.js");
 const fieldChangeHandler_js_1 = require("./fieldChangeHandler.js");
 const genericFieldKind_js_1 = require("./genericFieldKind.js");
 const modularChangeTypes_js_1 = require("./modularChangeTypes.js");
+const modularChangeUtils_js_1 = require("./modularChangeUtils.js");
+const invert_js_1 = require("./invert.js");
+const prune_js_1 = require("./prune.js");
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -30,6 +32,9 @@ class ModularChangeFamily {
     get rebaser() {
         return this;
     }
+    buildProcessor(processFn) {
+        return (change) => processFn(change, this);
+    }
     /**
      * Produces an equivalent list of `FieldChangeset`s that all target the same {@link FlexFieldKind}.
      * @param changes - The list of `FieldChange`s whose `FieldChangeset`s needs to be normalized.
@@ -51,8 +56,7 @@ class ModularChangeFamily {
                 change2: change2.change,
             };
         }
-        const fieldKind = getFieldKind(this.fieldKinds, kind);
-        const changeHandler = fieldKind.changeHandler;
+        const changeHandler = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, kind);
         const normalizedChange1 = this.normalizeFieldChange(change1, changeHandler);
         const normalizedChange2 = this.normalizeFieldChange(change2, changeHandler);
         return {
@@ -72,13 +76,13 @@ class ModularChangeFamily {
         return convertedChange;
     }
     compose(changes) {
-        const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
+        const { revInfos, maxId } = (0, modularChangeUtils_js_1.getRevInfoFromTaggedChanges)(changes);
         const idState = { maxId };
         const pairwiseDelegate = (left, right) => {
             return this.composePair(left, right, revInfos, idState);
         };
         const innerChanges = changes.map((change) => change.change);
-        return (0, index_js_3.balancedReduce)(innerChanges, pairwiseDelegate, makeModularChangeset);
+        return (0, index_js_3.balancedReduce)(innerChanges, pairwiseDelegate, modularChangeUtils_js_1.makeModularChangeset);
     }
     composePair(change1, change2, revInfos, idState) {
         const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
@@ -86,7 +90,7 @@ class ModularChangeFamily {
         // The composed changeset has a "no change" constraint if either change has one
         const noChangeConstraint = change1.noChangeConstraint ?? change2.noChangeConstraint;
         const noChangeConstraintOnRevert = change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
-        return makeModularChangeset({
+        return (0, modularChangeUtils_js_1.makeModularChangeset)({
             fieldChanges,
             nodeChanges,
             nodeToParent,
@@ -137,7 +141,7 @@ class ModularChangeFamily {
         const context = crossFieldTable.fieldToContext.get(fieldChange);
         (0, internal_1.assert)(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
         const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
-        const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
+        const rebaser = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, composedChange.fieldKind).rebaser;
         const composeNodes = (child1, child2) => {
             if (child1 !== undefined &&
                 child2 !== undefined &&
@@ -215,7 +219,7 @@ class ModularChangeFamily {
                 continue;
             }
             const nodeId = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
-            let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
+            let nodeChangeset = (0, modularChangeUtils_js_1.nodeChangeFromId)(composedNodes, nodeId);
             if (!table.composedNodes.has(nodeChangeset)) {
                 nodeChangeset = cloneNodeChangeset(nodeChangeset);
                 (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(composedNodes, nodeId, nodeChangeset);
@@ -283,8 +287,8 @@ class ModularChangeFamily {
         return composedField;
     }
     composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
-        const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
-        const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
+        const nodeChangeset1 = (0, modularChangeUtils_js_1.nodeChangeFromId)(nodeChanges1, id1);
+        const nodeChangeset2 = (0, modularChangeUtils_js_1.nodeChangeFromId)(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(composedNodes, id1, composedNodeChangeset);
         if (!(0, index_js_2.areEqualChangeAtomIds)(id1, id2)) {
@@ -322,106 +326,8 @@ class ModularChangeFamily {
         }
         return composedNodeChange;
     }
-    /**
-     * @param change - The change to invert.
-     * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
-     * performing a sandwich rebase.
-     * @param revisionForInvert - The revision for the invert changeset.
-     */
     invert(change, isRollback, revisionForInvert) {
-        // Rollback changesets destroy the nodes created by the change being rolled back.
-        const destroys = isRollback ? invertBuilds(change.change.builds) : undefined;
-        // Destroys only occur in rollback changesets, which are never inverted.
-        (0, internal_1.assert)(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
-        const revInfos = isRollback
-            ? [{ revision: revisionForInvert, rollbackOf: change.revision }]
-            : [{ revision: revisionForInvert }];
-        const noChangeConstraint = change.change.noChangeConstraintOnRevert;
-        const noChangeConstraintOnRevert = change.change.noChangeConstraint;
-        if (hasConflicts(change.change)) {
-            return makeModularChangeset({
-                maxId: change.change.maxId,
-                revisions: revInfos,
-                destroys,
-            });
-        }
-        const genId = (0, index_js_3.idAllocatorFromMaxId)(change.change.maxId ?? -1);
-        const crossFieldTable = {
-            ...newCrossFieldTable(),
-            originalFieldToContext: new Map(),
-            invertedNodeToParent: (0, index_js_3.brand)(change.change.nodeToParent.clone()),
-        };
-        const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
-        const revisionMetadata = (0, index_js_2.revisionMetadataSourceFromInfo)(oldRevInfos);
-        const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
-        const invertedNodes = (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)();
-        change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
-            invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert));
-        });
-        if (crossFieldTable.invalidatedFields.size > 0) {
-            const fieldsToUpdate = crossFieldTable.invalidatedFields;
-            crossFieldTable.invalidatedFields = new Set();
-            for (const fieldChange of fieldsToUpdate) {
-                const originalFieldChange = fieldChange.change;
-                const context = crossFieldTable.originalFieldToContext.get(fieldChange);
-                (0, internal_1.assert)(context !== undefined, 0x851 /* Should have context for every invalidated field */);
-                const { invertedField, fieldId } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
-                invertedField.change = (0, index_js_3.brand)(amendedChange);
-            }
-        }
-        const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
-        const constraintState = newConstraintState(0);
-        this.updateConstraintsForFields(invertedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, invertedNodes);
-        return makeModularChangeset({
-            fieldChanges: invertedFields,
-            nodeChanges: invertedNodes,
-            nodeToParent: crossFieldTable.invertedNodeToParent,
-            nodeAliases: change.change.nodeAliases,
-            crossFieldKeys,
-            maxId: genId.getMaxId(),
-            revisions: revInfos,
-            constraintViolationCount: constraintState.violationCount,
-            noChangeConstraint,
-            noChangeConstraintOnRevert,
-            destroys,
-        });
-    }
-    invertFieldMap(changes, parentId, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert) {
-        const invertedFields = new Map();
-        for (const [field, fieldChange] of changes) {
-            const fieldId = { nodeId: parentId, field };
-            const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
-            const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
-            const invertedFieldChange = {
-                ...fieldChange,
-                change: (0, index_js_3.brand)(invertedChange),
-            };
-            invertedFields.set(field, invertedFieldChange);
-            crossFieldTable.originalFieldToContext.set(fieldChange, {
-                fieldId,
-                invertedField: invertedFieldChange,
-            });
-        }
-        return invertedFields;
-    }
-    invertNodeChange(change, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert) {
-        const inverse = {};
-        // If the node has a constraint, it should be inverted to a node-exist-on-revert constraint. This ensure that if
-        // the inverse is inverted again, the original input constraint will be restored.
-        if (change.nodeExistsConstraint !== undefined) {
-            inverse.nodeExistsConstraintOnRevert = change.nodeExistsConstraint;
-        }
-        // The node-exist-on-revert constraint of a node is the constraint that should apply when the a change is reverted.
-        // So, it should become the constraint in the inverse. If this constraint is violated when applying the inverse,
-        // it will be discarded.
-        if (change.nodeExistsConstraintOnRevert !== undefined) {
-            inverse.nodeExistsConstraint = change.nodeExistsConstraintOnRevert;
-        }
-        if (change.fieldChanges !== undefined) {
-            inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
-        }
-        return inverse;
+        return (0, invert_js_1.invertModularChange)(change, isRollback, revisionForInvert, this.fieldKinds);
     }
     rebase(taggedChange, potentiallyConflictedOver, revisionMetadata, ignoreNoChangeViolation = false) {
         // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
@@ -434,7 +340,7 @@ class ModularChangeFamily {
         const idState = { maxId };
         const genId = (0, index_js_3.idAllocatorFromState)(idState);
         const crossFieldTable = {
-            ...newCrossFieldTable(),
+            ...(0, modularChangeUtils_js_1.newCrossFieldTable)(),
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
@@ -446,7 +352,7 @@ class ModularChangeFamily {
             affectedBaseFields: newFieldIdKeyBTree(),
             fieldsWithUnattachedChild: new Set(),
         };
-        const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
+        const getBaseRevisions = () => (0, modularChangeUtils_js_1.revisionInfoFromTaggedChange)(over).map((info) => info.revision);
         const rebaseMetadata = {
             ...revisionMetadata,
             getRevisionToRebase: () => taggedChange.revision,
@@ -455,7 +361,7 @@ class ModularChangeFamily {
         const rebasedNodes = (0, index_js_3.brand)(change.nodeChanges.clone());
         const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
         this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
-        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
+        const constraintState = (0, modularChangeUtils_js_1.newConstraintState)(change.constraintViolationCount ?? 0);
         let noChangeConstraint = change.noChangeConstraint;
         if (noChangeConstraint !== undefined &&
             !noChangeConstraint.violated &&
@@ -463,9 +369,9 @@ class ModularChangeFamily {
             noChangeConstraint = { violated: true };
             constraintState.violationCount += 1;
         }
-        this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes);
-        const rebased = makeModularChangeset({
-            fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
+        (0, modularChangeUtils_js_1.updateConstraintsForFields)(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes, this.fieldKinds);
+        const rebased = (0, modularChangeUtils_js_1.makeModularChangeset)({
+            fieldChanges: (0, prune_js_1.pruneFieldMap)(rebasedFields, rebasedNodes, this.fieldKinds),
             nodeChanges: rebasedNodes,
             nodeToParent: crossFieldTable.rebasedNodeToParent,
             nodeAliases: change.nodeAliases,
@@ -510,7 +416,7 @@ class ModularChangeFamily {
             }
             // This field has no changes in the new changeset, otherwise it would have been added to
             // `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
-            const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+            const handler = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, baseFieldChange.fieldKind);
             const fieldChange = {
                 ...baseFieldChange,
                 change: (0, index_js_3.brand)(handler.createEmpty()),
@@ -608,7 +514,7 @@ class ModularChangeFamily {
             table.fieldsWithUnattachedChild.add(baseFieldChange);
             return;
         }
-        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+        const handler = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, baseFieldChange.fieldKind);
         const fieldChange = {
             ...baseFieldChange,
             change: (0, index_js_3.brand)(handler.createEmpty()),
@@ -662,8 +568,8 @@ class ModularChangeFamily {
         return rebasedFields;
     }
     rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata) {
-        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
-        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
+        const change = (0, modularChangeUtils_js_1.nodeChangeFromId)(crossFieldTable.newChange.nodeChanges, newId);
+        const over = (0, modularChangeUtils_js_1.nodeChangeFromId)(crossFieldTable.baseChange.nodeChanges, baseId);
         const baseMap = over?.fieldChanges ?? new Map();
         const fieldChanges = change.fieldChanges !== undefined && over.fieldChanges !== undefined
             ? this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, newId, genId, crossFieldTable, revisionMetadata)
@@ -681,66 +587,6 @@ class ModularChangeFamily {
         (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
-    updateConstraintsForFields(fields, parentInputAttachState, constraintState, nodes) {
-        for (const field of fields.values()) {
-            const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-            for (const [nodeId, inputIndex, _outputIndex] of handler.getNestedChanges(field.change)) {
-                const isInputDetached = inputIndex === undefined;
-                const inputAttachState = parentInputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached || isInputDetached
-                    ? fieldChangeHandler_js_1.NodeAttachState.Detached
-                    : fieldChangeHandler_js_1.NodeAttachState.Attached;
-                this.updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState);
-            }
-        }
-    }
-    updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState) {
-        const node = nodes.get([nodeId.revision, nodeId.localId]) ?? (0, internal_1.fail)(0xb24 /* Unknown node ID */);
-        if (node.nodeExistsConstraint !== undefined) {
-            const isNowViolated = inputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
-            if (node.nodeExistsConstraint.violated !== isNowViolated) {
-                node.nodeExistsConstraint = {
-                    ...node.nodeExistsConstraint,
-                    violated: isNowViolated,
-                };
-                constraintState.violationCount += isNowViolated ? 1 : -1;
-            }
-        }
-        if (node.fieldChanges !== undefined) {
-            this.updateConstraintsForFields(node.fieldChanges, inputAttachState, constraintState, nodes);
-        }
-    }
-    pruneFieldMap(changeset, nodeMap) {
-        if (changeset === undefined) {
-            return undefined;
-        }
-        const prunedChangeset = new Map();
-        for (const [field, fieldChange] of changeset) {
-            const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
-            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap));
-            if (!handler.isEmpty(prunedFieldChangeset)) {
-                prunedChangeset.set(field, { ...fieldChange, change: (0, index_js_3.brand)(prunedFieldChangeset) });
-            }
-        }
-        return prunedChangeset.size > 0 ? prunedChangeset : undefined;
-    }
-    pruneNodeChange(nodeId, nodeMap) {
-        const changeset = nodeChangeFromId(nodeMap, nodeId);
-        const prunedFields = changeset.fieldChanges === undefined
-            ? undefined
-            : this.pruneFieldMap(changeset.fieldChanges, nodeMap);
-        const prunedChange = { ...changeset, fieldChanges: prunedFields };
-        if (prunedChange.fieldChanges === undefined) {
-            delete prunedChange.fieldChanges;
-        }
-        if (isEmptyNodeChangeset(prunedChange)) {
-            nodeMap.delete([nodeId.revision, nodeId.localId]);
-            return undefined;
-        }
-        else {
-            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeMap, nodeId, prunedChange);
-            return nodeId;
-        }
-    }
     getRevisions(change) {
         if (change.revisions === undefined || change.revisions.length === 0) {
             return new Set([undefined]);
@@ -786,37 +632,16 @@ class ModularChangeFamily {
     replaceFieldMapRevisions(fields, replacer) {
         const updatedFields = new Map();
         for (const [field, fieldChange] of fields) {
-            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, replacer);
+            const updatedFieldChange = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, replacer);
             updatedFields.set(field, { ...fieldChange, change: (0, index_js_3.brand)(updatedFieldChange) });
         }
         return updatedFields;
     }
-    makeCrossFieldKeyTable(fields, nodes) {
-        const keys = (0, modularChangeTypes_js_1.newCrossFieldKeyTable)();
-        this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
-        nodes.forEachPair(([revision, localId], node) => {
-            if (node.fieldChanges !== undefined) {
-                this.populateCrossFieldKeyTableForFieldMap(keys, node.fieldChanges, {
-                    revision,
-                    localId,
-                });
-            }
-        });
-        return keys;
-    }
-    populateCrossFieldKeyTableForFieldMap(table, fields, parent) {
-        for (const [fieldKey, fieldChange] of fields) {
-            const keys = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).getCrossFieldKeys(fieldChange.change);
-            for (const { key, count } of keys) {
-                table.set(key, count, { nodeId: parent, field: fieldKey });
-            }
-        }
-    }
     buildEditor(mintRevisionTag, changeReceiver) {
-        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
+        return new ModularEditBuilder(this.rebaser, this.fieldKinds, changeReceiver, this.codecOptions);
     }
     createEmptyFieldChange(fieldKind) {
-        const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
+        const emptyChange = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, fieldKind).createEmpty();
         return { fieldKind, change: (0, index_js_3.brand)(emptyChange) };
     }
     validateChangeset(change) {
@@ -840,7 +665,7 @@ class ModularChangeFamily {
         let numChildren = 0;
         for (const [field, fieldChange] of fieldChanges.entries()) {
             const fieldId = { nodeId: nodeParent, field };
-            const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
+            const handler = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, fieldChange.fieldKind);
             for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
                 const parentFieldId = getParentFieldId(change, child);
                 (0, internal_1.assert)(areEqualFieldIds(parentFieldId, fieldId), 0xa4e /* Inconsistent node parentage */);
@@ -856,7 +681,7 @@ class ModularChangeFamily {
         return numChildren;
     }
     getEffectiveChange(change) {
-        if (hasConflicts(change)) {
+        if ((0, modularChangeUtils_js_1.hasConflicts)(change)) {
             return this.muteChange(change);
         }
         return change;
@@ -886,7 +711,7 @@ class ModularChangeFamily {
         return new Map(Array.from(change.entries(), ([key, value]) => [key, this.muteFieldChange(value)]));
     }
     muteFieldChange(change) {
-        const handler = getChangeHandler(this.fieldKinds, change.fieldKind);
+        const handler = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, change.fieldKind);
         return {
             fieldKind: change.fieldKind,
             change: (0, index_js_3.brand)(handler.rebaser.filterEdits(change.change, {
@@ -898,7 +723,7 @@ class ModularChangeFamily {
     }
 }
 exports.ModularChangeFamily = ModularChangeFamily;
-ModularChangeFamily.emptyChange = makeModularChangeset();
+ModularChangeFamily.emptyChange = (0, modularChangeUtils_js_1.makeModularChangeset)();
 function removeAllEditsFilter(_id, count, _endpointId) {
     return { value: fieldChangeHandler_js_1.EditFilterStatus.Remove, length: count };
 }
@@ -964,12 +789,6 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
     }
     return { allBuilds, allDestroys, allRefreshers };
 }
-function invertBuilds(builds) {
-    if (builds !== undefined) {
-        return (0, index_js_3.brand)(builds.mapValues((chunk) => chunk.topLevelLength));
-    }
-    return undefined;
-}
 /**
  * Returns the set of removed roots that should be in memory for the given change to be applied.
  * A removed root is relevant if any of the following is true:
@@ -990,7 +809,7 @@ function* relevantRemovedRoots(change, fieldKinds) {
 }
 exports.relevantRemovedRoots = relevantRemovedRoots;
 function* relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds) {
-    const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+    const nodeChangeset = (0, modularChangeUtils_js_1.nodeChangeFromId)(nodeChanges, node);
     if (nodeChangeset.fieldChanges !== undefined) {
         yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
     }
@@ -998,7 +817,7 @@ function* relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds) {
 function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
     const delegate = (node) => relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds);
     for (const [_, fieldChange] of change) {
-        const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+        const handler = (0, modularChangeUtils_js_1.getChangeHandler)(fieldKinds, fieldChange.fieldKind);
         yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
     }
 }
@@ -1046,7 +865,7 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
         }
     }
     const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
-    return makeModularChangeset({
+    return (0, modularChangeUtils_js_1.makeModularChangeset)({
         fieldChanges,
         nodeChanges,
         nodeToParent,
@@ -1072,7 +891,7 @@ function intoDelta(taggedChange, fieldKinds) {
     const rootDelta = {};
     const global = [];
     const rename = [];
-    if (!hasConflicts(change)) {
+    if (!(0, modularChangeUtils_js_1.hasConflicts)(change)) {
         // If there are no constraint violations, then tree changes apply.
         const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds, global, rename);
         if (fieldDeltas.size > 0) {
@@ -1124,8 +943,8 @@ function copyDetachedNodes(detachedNodes) {
 function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
-            const nodeChange = nodeChangeFromId(nodeChanges, childChange);
+        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = (0, modularChangeUtils_js_1.getChangeHandler)(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+            const nodeChange = (0, modularChangeUtils_js_1.nodeChangeFromId)(nodeChanges, childChange);
             return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
         });
         if (fieldChanges !== undefined && fieldChanges.marks.length > 0) {
@@ -1174,27 +993,9 @@ function rebaseRevisionMetadataFromInfo(revInfos, revisionToRebase, baseRevision
     };
 }
 exports.rebaseRevisionMetadataFromInfo = rebaseRevisionMetadataFromInfo;
-function isEmptyNodeChangeset(change) {
-    return (change.fieldChanges === undefined &&
-        change.nodeExistsConstraint === undefined &&
-        change.nodeExistsConstraintOnRevert === undefined);
-}
-function getFieldKind(fieldKinds, kind) {
-    if (kind === genericFieldKind_js_1.genericFieldKind.identifier) {
-        return genericFieldKind_js_1.genericFieldKind;
-    }
-    const fieldKind = fieldKinds.get(kind);
-    (0, internal_1.assert)(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
-    return fieldKind;
-}
-exports.getFieldKind = getFieldKind;
-function getChangeHandler(fieldKinds, kind) {
-    return getFieldKind(fieldKinds, kind).changeHandler;
-}
-exports.getChangeHandler = getChangeHandler;
 function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
-        ...newCrossFieldTable(),
+        ...(0, modularChangeUtils_js_1.newCrossFieldTable)(),
         baseChange,
         newChange,
         fieldToContext: new Map(),
@@ -1209,76 +1010,7 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
         },
     };
 }
-function newCrossFieldTable() {
-    return {
-        srcTable: (0, index_js_2.newChangeAtomIdRangeMap)(),
-        dstTable: (0, index_js_2.newChangeAtomIdRangeMap)(),
-        srcDependents: (0, index_js_2.newChangeAtomIdRangeMap)(),
-        dstDependents: (0, index_js_2.newChangeAtomIdRangeMap)(),
-        invalidatedFields: new Set(),
-    };
-}
-function newConstraintState(violationCount) {
-    return {
-        violationCount,
-    };
-}
-class CrossFieldManagerI {
-    constructor(crossFieldTable, currentFieldKey, allowInval = true) {
-        this.crossFieldTable = crossFieldTable;
-        this.currentFieldKey = currentFieldKey;
-        this.allowInval = allowInval;
-    }
-    set(target, revision, id, count, newValue, invalidateDependents) {
-        if (invalidateDependents && this.allowInval) {
-            const lastChangedId = id + count - 1;
-            let firstId = id;
-            while (firstId <= lastChangedId) {
-                const dependentEntry = (0, crossFieldQueries_js_1.getFirstFromCrossFieldMap)(this.getDependents(target), revision, firstId, lastChangedId - firstId + 1);
-                if (dependentEntry.value !== undefined) {
-                    this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
-                }
-                firstId = (0, index_js_3.brand)(firstId + dependentEntry.length);
-            }
-        }
-        (0, crossFieldQueries_js_1.setInCrossFieldMap)(this.getMap(target), revision, id, count, newValue);
-    }
-    get(target, revision, id, count, addDependency) {
-        if (addDependency) {
-            // We assume that if there is already an entry for this ID it is because
-            // a field handler has called compose on the same node multiple times.
-            // In this case we only want to update the latest version, so we overwrite the dependency.
-            (0, crossFieldQueries_js_1.setInCrossFieldMap)(this.getDependents(target), revision, id, count, this.currentFieldKey);
-        }
-        return (0, crossFieldQueries_js_1.getFirstFromCrossFieldMap)(this.getMap(target), revision, id, count);
-    }
-    getMap(target) {
-        return target === crossFieldQueries_js_1.CrossFieldTarget.Source
-            ? this.crossFieldTable.srcTable
-            : this.crossFieldTable.dstTable;
-    }
-    getDependents(target) {
-        return target === crossFieldQueries_js_1.CrossFieldTarget.Source
-            ? this.crossFieldTable.srcDependents
-            : this.crossFieldTable.dstDependents;
-    }
-}
-class InvertManager extends CrossFieldManagerI {
-    constructor(table, field, fieldId, allowInval = true) {
-        super(table, field, allowInval);
-        this.fieldId = fieldId;
-    }
-    onMoveIn(id) {
-        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(this.table.invertedNodeToParent, id, this.fieldId);
-    }
-    moveKey(target, revision, id, count) {
-        (0, internal_1.assert)(false, 0x9c5 /* Keys should not be moved manually during invert */);
-    }
-    get table() {
-        return this.crossFieldTable;
-    }
-}
-class RebaseManager extends CrossFieldManagerI {
+class RebaseManager extends modularChangeUtils_js_1.CrossFieldManagerI {
     constructor(table, currentField, fieldId, allowInval = true) {
         super(table, currentField, allowInval);
         this.fieldId = fieldId;
@@ -1314,7 +1046,7 @@ class RebaseManager extends CrossFieldManagerI {
     }
 }
 // TODO: Deduplicate this with RebaseTable
-class ComposeManager extends CrossFieldManagerI {
+class ComposeManager extends modularChangeUtils_js_1.CrossFieldManagerI {
     constructor(table, currentField, fieldId, allowInval = true) {
         super(table, currentField, allowInval);
         this.fieldId = fieldId;
@@ -1355,44 +1087,10 @@ class ComposeManager extends CrossFieldManagerI {
         return this.crossFieldTable;
     }
 }
-function makeModularChangeset(props) {
-    const p = props ?? { maxId: -1 };
-    const changeset = {
-        fieldChanges: p.fieldChanges ?? new Map(),
-        nodeChanges: p.nodeChanges ?? (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
-        nodeToParent: p.nodeToParent ?? (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
-        nodeAliases: p.nodeAliases ?? (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
-        crossFieldKeys: p.crossFieldKeys ?? (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
-    };
-    if (p.revisions !== undefined && p.revisions.length > 0) {
-        changeset.revisions = p.revisions;
-    }
-    if (p.maxId >= 0) {
-        changeset.maxId = (0, index_js_3.brand)(p.maxId);
-    }
-    if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {
-        changeset.constraintViolationCount = p.constraintViolationCount;
-    }
-    if (p.noChangeConstraint !== undefined) {
-        changeset.noChangeConstraint = p.noChangeConstraint;
-    }
-    if (p.noChangeConstraintOnRevert !== undefined) {
-        changeset.noChangeConstraintOnRevert = p.noChangeConstraintOnRevert;
-    }
-    if (p.builds !== undefined && p.builds.size > 0) {
-        changeset.builds = p.builds;
-    }
-    if (p.destroys !== undefined && p.destroys.size > 0) {
-        changeset.destroys = p.destroys;
-    }
-    if (p.refreshers !== undefined && p.refreshers.size > 0) {
-        changeset.refreshers = p.refreshers;
-    }
-    return changeset;
-}
 class ModularEditBuilder extends index_js_2.EditBuilder {
-    constructor(family, fieldKinds, changeReceiver, codecOptions) {
-        super(family, changeReceiver);
+    constructor(rebaser, fieldKinds, changeReceiver, codecOptions) {
+        super(changeReceiver);
+        this.rebaser = rebaser;
         this.fieldKinds = fieldKinds;
         this.transactionDepth = 0;
         this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
@@ -1442,7 +1140,7 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
      * @param revision - the revision of the change
      */
     submitChange(field, fieldKind, change, revision) {
-        const localCrossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
+        const localCrossFieldKeys = (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
         const modularChange = buildModularChangesetFromField({
             path: field,
             fieldChange: { fieldKind, change },
@@ -1464,7 +1162,7 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
         const changeMaps = changes.map((change) => {
             revisions.add(change.revision);
             return (0, index_js_2.makeAnonChange)(change.type === "global"
-                ? makeModularChangeset({
+                ? (0, modularChangeUtils_js_1.makeModularChangeset)({
                     maxId: this.idAllocator.getMaxId(),
                     builds: change.builds,
                     revisions: [{ revision: change.revision }],
@@ -1479,13 +1177,13 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
                     nodeToParent: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
                     crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
                     idAllocator: this.idAllocator,
-                    localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
+                    localCrossFieldKeys: (0, modularChangeUtils_js_1.getChangeHandler)(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
                 }));
         });
         const revInfo = [...revisions].map((revision) => ({ revision }));
         const composedChange = {
-            ...this.changeFamily.rebaser.compose(changeMaps),
+            ...this.rebaser.compose(changeMaps),
             revisions: revInfo,
         };
         const maxId = (0, index_js_3.brand)(this.idAllocator.getMaxId());
@@ -1529,7 +1227,7 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
         if ((0, semver_ts_1.lt)(this.codecOptions.minVersionForCollab, index_js_1.FluidClientVersion.v2_80)) {
             throw new internal_2.UsageError(`No change constraints require min client version of at least ${index_js_1.FluidClientVersion.v2_80}`);
         }
-        const changeset = makeModularChangeset({
+        const changeset = (0, modularChangeUtils_js_1.makeModularChangeset)({
             maxId: -1,
             noChangeConstraint: { violated: false },
         });
@@ -1539,7 +1237,7 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
         if ((0, semver_ts_1.lt)(this.codecOptions.minVersionForCollab, index_js_1.FluidClientVersion.v2_80)) {
             throw new internal_2.UsageError(`No change constraints require min client version of at least ${index_js_1.FluidClientVersion.v2_80}`);
         }
-        const changeset = makeModularChangeset({
+        const changeset = (0, modularChangeUtils_js_1.makeModularChangeset)({
             maxId: -1,
             noChangeConstraintOnRevert: { violated: false },
         });
@@ -1560,7 +1258,7 @@ function buildModularChangesetFromField(props) {
                 field: path.field,
             });
         }
-        return makeModularChangeset({
+        return (0, modularChangeUtils_js_1.makeModularChangeset)({
             fieldChanges,
             nodeChanges,
             nodeToParent,
@@ -1611,49 +1309,6 @@ function buildModularChangesetFromNode(props) {
         childId: nodeId,
     });
 }
-function getRevInfoFromTaggedChanges(changes) {
-    let maxId = -1;
-    const revInfos = [];
-    const revisions = new Set();
-    for (const taggedChange of changes) {
-        const change = taggedChange.change;
-        maxId = Math.max(change.maxId ?? -1, maxId);
-        const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
-        for (const info of infosToAdd) {
-            if (!revisions.has(info.revision)) {
-                revisions.add(info.revision);
-                revInfos.push(info);
-            }
-        }
-    }
-    const rolledBackRevisions = [];
-    for (const info of revInfos) {
-        if (info.rollbackOf !== undefined) {
-            rolledBackRevisions.push(info.rollbackOf);
-        }
-    }
-    rolledBackRevisions.reverse();
-    for (const revision of rolledBackRevisions) {
-        if (!revisions.has(revision)) {
-            revInfos.push({ revision });
-        }
-    }
-    return { maxId: (0, index_js_3.brand)(maxId), revInfos };
-}
-function revisionInfoFromTaggedChange(taggedChange) {
-    const revInfos = [];
-    if (taggedChange.change.revisions !== undefined) {
-        revInfos.push(...taggedChange.change.revisions);
-    }
-    else if (taggedChange.revision !== undefined) {
-        const info = { revision: taggedChange.revision };
-        if (taggedChange.rollbackOf !== undefined) {
-            info.rollbackOf = taggedChange.rollbackOf;
-        }
-        revInfos.push(info);
-    }
-    return revInfos;
-}
 function fieldChangeFromId(fields, nodes, id) {
     const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
     return fieldMap.get(id.field) ?? (0, internal_1.fail)(0xb25 /* No field exists for the given ID */);
@@ -1662,7 +1317,7 @@ function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
     if (nodeId === undefined) {
         return rootFieldMap;
     }
-    const node = nodeChangeFromId(nodes, nodeId);
+    const node = (0, modularChangeUtils_js_1.nodeChangeFromId)(nodes, nodeId);
     (0, internal_1.assert)(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
@@ -1675,11 +1330,6 @@ function rebasedFieldIdFromBaseId(table, baseId) {
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
     return (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
-function nodeChangeFromId(nodes, id) {
-    const node = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(nodes, id);
-    (0, internal_1.assert)(node !== undefined, 0x9ca /* Unknown node ID */);
-    return node;
-}
 function fieldIdFromFieldIdKey([revision, localId, field]) {
     const nodeId = localId === undefined ? undefined : { revision, localId };
     return { nodeId, field };
@@ -1734,9 +1384,6 @@ function normalizeNodeId(nodeId, nodeAliases) {
         currentId = dealiased;
     }
 }
-function hasConflicts(change) {
-    return (change.constraintViolationCount ?? 0) > 0;
-}
 /**
  * A rebaseChild callback for fields with no new changes.
  * Asserts that there are no new changes and returns undefined.