@fluidframework/tree 2.113.0-411909 → 2.114.0

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

@@ -7,13 +7,15 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
 import { lt } from "semver-ts";
 import { FluidClientVersion, } from "../../codec/index.js";
-import { EditBuilder, makeDetachedNodeId, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, mapTaggedChange, comparePartialRevisions, comparePartialChangesetLocalIds, } from "../../core/index.js";
+import { EditBuilder, makeDetachedNodeId, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, mapTaggedChange, comparePartialRevisions, comparePartialChangesetLocalIds, } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, mergeTupleBTrees, RangeMap, balancedReduce, newTupleBTree, compareStrings, createTupleComparator, } from "../../util/index.js";
 import { getFromChangeAtomIdMap, newChangeAtomIdBTree, setInChangeAtomIdMap, } from "../changeAtomIdBTree.js";
-import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { EditFilterStatus, NodeAttachState, } from "./fieldChangeHandler.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
+import { CrossFieldManagerI, getChangeHandler, getRevInfoFromTaggedChanges, hasConflicts, makeModularChangeset, newConstraintState, newCrossFieldTable, nodeChangeFromId, revisionInfoFromTaggedChange, updateConstraintsForFields, } from "./modularChangeUtils.js";
+import { invertModularChange } from "./invert.js";
+import { pruneFieldMap } from "./prune.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -27,6 +29,9 @@ export 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.
@@ -48,8 +53,7 @@ export class ModularChangeFamily {
                 change2: change2.change,
             };
         }
-        const fieldKind = getFieldKind(this.fieldKinds, kind);
-        const changeHandler = fieldKind.changeHandler;
+        const changeHandler = getChangeHandler(this.fieldKinds, kind);
         const normalizedChange1 = this.normalizeFieldChange(change1, changeHandler);
         const normalizedChange2 = this.normalizeFieldChange(change2, changeHandler);
         return {
@@ -319,106 +323,8 @@ export 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.
-        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 = idAllocatorFromMaxId(change.change.maxId ?? -1);
-        const crossFieldTable = {
-            ...newCrossFieldTable(),
-            originalFieldToContext: new Map(),
-            invertedNodeToParent: brand(change.change.nodeToParent.clone()),
-        };
-        const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
-        const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
-        const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
-        const invertedNodes = 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);
-                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 = brand(amendedChange);
-            }
-        }
-        const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
-        const constraintState = newConstraintState(0);
-        this.updateConstraintsForFields(invertedFields, 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: 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 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.
@@ -460,9 +366,9 @@ export class ModularChangeFamily {
             noChangeConstraint = { violated: true };
             constraintState.violationCount += 1;
         }
-        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, constraintState, rebasedNodes);
+        updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, constraintState, rebasedNodes, this.fieldKinds);
         const rebased = makeModularChangeset({
-            fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
+            fieldChanges: pruneFieldMap(rebasedFields, rebasedNodes, this.fieldKinds),
             nodeChanges: rebasedNodes,
             nodeToParent: crossFieldTable.rebasedNodeToParent,
             nodeAliases: change.nodeAliases,
@@ -678,66 +584,6 @@ export class ModularChangeFamily {
         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 === NodeAttachState.Detached || isInputDetached
-                    ? NodeAttachState.Detached
-                    : NodeAttachState.Attached;
-                this.updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState);
-            }
-        }
-    }
-    updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState) {
-        const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
-        if (node.nodeExistsConstraint !== undefined) {
-            const isNowViolated = inputAttachState === 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: 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 {
-            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
-            return nodeId;
-        }
-    }
     getRevisions(change) {
         if (change.revisions === undefined || change.revisions.length === 0) {
             return new Set([undefined]);
@@ -788,29 +634,8 @@ export class ModularChangeFamily {
         }
         return updatedFields;
     }
-    makeCrossFieldKeyTable(fields, nodes) {
-        const keys = 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();
@@ -960,12 +785,6 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
     }
     return { allBuilds, allDestroys, allRefreshers };
 }
-function invertBuilds(builds) {
-    if (builds !== undefined) {
-        return 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:
@@ -1166,22 +985,6 @@ export function rebaseRevisionMetadataFromInfo(revInfos, revisionToRebase, baseR
         getBaseRevisions,
     };
 }
-function isEmptyNodeChangeset(change) {
-    return (change.fieldChanges === undefined &&
-        change.nodeExistsConstraint === undefined &&
-        change.nodeExistsConstraintOnRevert === undefined);
-}
-export function getFieldKind(fieldKinds, kind) {
-    if (kind === genericFieldKind.identifier) {
-        return genericFieldKind;
-    }
-    const fieldKind = fieldKinds.get(kind);
-    assert(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
-    return fieldKind;
-}
-export function getChangeHandler(fieldKinds, kind) {
-    return getFieldKind(fieldKinds, kind).changeHandler;
-}
 function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
         ...newCrossFieldTable(),
@@ -1199,75 +1002,6 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
         },
     };
 }
-function newCrossFieldTable() {
-    return {
-        srcTable: newChangeAtomIdRangeMap(),
-        dstTable: newChangeAtomIdRangeMap(),
-        srcDependents: newChangeAtomIdRangeMap(),
-        dstDependents: 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 = getFirstFromCrossFieldMap(this.getDependents(target), revision, firstId, lastChangedId - firstId + 1);
-                if (dependentEntry.value !== undefined) {
-                    this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
-                }
-                firstId = brand(firstId + dependentEntry.length);
-            }
-        }
-        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.
-            setInCrossFieldMap(this.getDependents(target), revision, id, count, this.currentFieldKey);
-        }
-        return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
-    }
-    getMap(target) {
-        return target === CrossFieldTarget.Source
-            ? this.crossFieldTable.srcTable
-            : this.crossFieldTable.dstTable;
-    }
-    getDependents(target) {
-        return target === 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) {
-        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
-    }
-    moveKey(target, revision, id, count) {
-        assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
-    }
-    get table() {
-        return this.crossFieldTable;
-    }
-}
 class RebaseManager extends CrossFieldManagerI {
     constructor(table, currentField, fieldId, allowInval = true) {
         super(table, currentField, allowInval);
@@ -1345,44 +1079,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 ?? newChangeAtomIdBTree(),
-        nodeToParent: p.nodeToParent ?? newChangeAtomIdBTree(),
-        nodeAliases: p.nodeAliases ?? newChangeAtomIdBTree(),
-        crossFieldKeys: p.crossFieldKeys ?? newCrossFieldKeyTable(),
-    };
-    if (p.revisions !== undefined && p.revisions.length > 0) {
-        changeset.revisions = p.revisions;
-    }
-    if (p.maxId >= 0) {
-        changeset.maxId = 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;
-}
 export class ModularEditBuilder extends 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 = idAllocatorFromMaxId();
@@ -1475,7 +1175,7 @@ export class ModularEditBuilder extends EditBuilder {
         });
         const revInfo = [...revisions].map((revision) => ({ revision }));
         const composedChange = {
-            ...this.changeFamily.rebaser.compose(changeMaps),
+            ...this.rebaser.compose(changeMaps),
             revisions: revInfo,
         };
         const maxId = brand(this.idAllocator.getMaxId());
@@ -1600,49 +1300,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: 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) ?? fail(0xb25 /* No field exists for the given ID */);
@@ -1664,11 +1321,6 @@ function rebasedFieldIdFromBaseId(table, baseId) {
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
     return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
-function nodeChangeFromId(nodes, id) {
-    const node = getFromChangeAtomIdMap(nodes, id);
-    assert(node !== undefined, 0x9ca /* Unknown node ID */);
-    return node;
-}
 function fieldIdFromFieldIdKey([revision, localId, field]) {
     const nodeId = localId === undefined ? undefined : { revision, localId };
     return { nodeId, field };
@@ -1721,9 +1373,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.