@fluidframework/tree 2.3.0-288113 → 2.4.0-294316

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

@@ -105,7 +105,6 @@ class ModularChangeFamily {
         }
         const genId = (0, index_js_2.idAllocatorFromState)(idState);
         const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(revInfos);
-        const crossFieldTable = newComposeTable(change1, change2);
         // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
         // The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
         // During composeFieldMaps and composeInvalidatedElements we will find all nodes referenced in both input changesets
@@ -117,7 +116,8 @@ class ModularChangeFamily {
         const composedNodeChanges = (0, index_js_2.brand)(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
         const composedNodeToParent = (0, index_js_2.brand)(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
         const composedNodeAliases = (0, index_js_2.brand)(mergeBTrees(change1.nodeAliases, change2.nodeAliases));
-        const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+        const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
         // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
         const composedCrossFieldKeys = mergeBTrees(change1.crossFieldKeys, change2.crossFieldKeys);
@@ -132,7 +132,7 @@ class ModularChangeFamily {
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
         const context = crossFieldTable.fieldToContext.get(fieldChange);
         (0, internal_1.assert)(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-        const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+        const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
         const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
         const composeNodes = (child1, child2) => {
             if (child1 !== undefined &&
@@ -143,7 +143,7 @@ class ModularChangeFamily {
             }
             return child1 ?? child2 ?? (0, index_js_2.fail)("Should not compose two undefined nodes");
         };
-        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, false), revisionMetadata);
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
         composedChange.change = (0, index_js_2.brand)(amendedChange);
     }
     /**
@@ -205,7 +205,7 @@ class ModularChangeFamily {
             const [change1, change2] = areBaseFields
                 ? [fieldChange, emptyChange]
                 : [emptyChange, fieldChange];
-            const composedField = this.composeFieldChanges(change1, change2, genId, table, metadata);
+            const composedField = this.composeFieldChanges(fieldId, change1, change2, genId, table, metadata);
             if (fieldId.nodeId === undefined) {
                 composedFields.set(fieldId.field, composedField);
                 continue;
@@ -223,15 +223,16 @@ class ModularChangeFamily {
         }
         affectedFields.clear();
     }
-    composeFieldMaps(change1, change2, genId, crossFieldTable, revisionMetadata) {
+    composeFieldMaps(change1, change2, parentId, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
         if (change1 === undefined || change2 === undefined) {
             return change1 ?? change2 ?? composedFields;
         }
         for (const [field, fieldChange1] of change1) {
+            const fieldId = { nodeId: parentId, field };
             const fieldChange2 = change2.get(field);
             const composedField = fieldChange2 !== undefined
-                ? this.composeFieldChanges(fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
+                ? this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
                 : fieldChange1;
             composedFields.set(field, composedField);
         }
@@ -253,9 +254,9 @@ class ModularChangeFamily {
      *
      * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
      */
-    composeFieldChanges(change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
+    composeFieldChanges(fieldId, change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
         const { fieldKind, changeHandler, change1: change1Normalized, change2: change2Normalized, } = this.normalizeFieldChanges(change1, change2, idAllocator, revisionMetadata);
-        const manager = new ComposeManager(crossFieldTable, change1);
+        const manager = new ComposeManager(crossFieldTable, change1, fieldId);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
                 setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
@@ -268,6 +269,7 @@ class ModularChangeFamily {
             change: (0, index_js_2.brand)(composedChange),
         };
         crossFieldTable.fieldToContext.set(change1, {
+            fieldId,
             change1: change1Normalized,
             change2: change2Normalized,
             composedChange: composedField,
@@ -278,7 +280,7 @@ class ModularChangeFamily {
     composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
         const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
         const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
-        const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
+        const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         if (!(0, index_js_1.areEqualChangeAtomIds)(id1, id2)) {
             composedNodes.delete([id2.revision, id2.localId]);
@@ -289,9 +291,9 @@ class ModularChangeFamily {
         }
         crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
-    composeNodeChanges(change1, change2, genId, crossFieldTable, revisionMetadata) {
+    composeNodeChanges(nodeId, change1, change2, genId, crossFieldTable, revisionMetadata) {
         const nodeExistsConstraint = change1.nodeExistsConstraint ?? change2.nodeExistsConstraint;
-        const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, nodeId, genId, crossFieldTable, revisionMetadata);
         const composedNodeChange = {};
         if (composedFieldChanges.size > 0) {
             composedNodeChange.fieldChanges = composedFieldChanges;
@@ -311,7 +313,7 @@ class ModularChangeFamily {
         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 */);
-        if ((change.change.constraintViolationCount ?? 0) > 0) {
+        if (hasConflicts(change.change)) {
             return makeModularChangeset(undefined, undefined, undefined, undefined, undefined, change.change.maxId, [], undefined, undefined, destroys);
         }
         const genId = (0, index_js_2.idAllocatorFromMaxId)(change.change.maxId ?? -1);
@@ -368,6 +370,9 @@ class ModularChangeFamily {
         return inverse;
     }
     rebase(taggedChange, over, revisionMetadata) {
+        if (hasConflicts(over.change)) {
+            return taggedChange.change;
+        }
         const change = taggedChange.change;
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
@@ -396,7 +401,8 @@ class ModularChangeFamily {
         const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, rebaseMetadata);
         this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes);
-        return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        const rebased = makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        return rebased;
     }
     // This performs a first pass on all fields which have both new and base changes.
     // TODO: Can we also handle additional passes in this method?
@@ -745,6 +751,42 @@ class ModularChangeFamily {
         const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
         return { fieldKind, change: (0, index_js_2.brand)(emptyChange) };
     }
+    validateChangeset(change) {
+        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+        for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+            if (node.fieldChanges === undefined) {
+                continue;
+            }
+            const nodeId = { revision, localId };
+            const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
+            numNodes += numChildren;
+        }
+        (0, internal_1.assert)(numNodes === change.nodeChanges.size, "Node table contains unparented nodes");
+    }
+    /**
+     * Asserts that each child and cross field key in each field has a correct entry in
+     * `nodeToParent` or `crossFieldKeyTable`.
+     * @returns the number of children found.
+     */
+    validateFieldChanges(change, fieldChanges, nodeParent) {
+        let numChildren = 0;
+        for (const [field, fieldChange] of fieldChanges.entries()) {
+            const fieldId = { nodeId: nodeParent, field };
+            const handler = 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), "Inconsistent node parentage");
+                numChildren += 1;
+            }
+            for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
+                const fields = getFieldsForCrossFieldKey(change, keyRange);
+                (0, internal_1.assert)(fields.length === 1 &&
+                    fields[0] !== undefined &&
+                    areEqualFieldIds(fields[0], fieldId), "Inconsistent cross field keys");
+            }
+        }
+        return numChildren;
+    }
 }
 exports.ModularChangeFamily = ModularChangeFamily;
 ModularChangeFamily.emptyChange = makeModularChangeset();
@@ -907,7 +949,7 @@ function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
     const idAllocator = memoizedIdRangeAllocator_js_1.MemoizedIdRangeAllocator.fromNextId();
     const rootDelta = {};
-    if ((change.constraintViolationCount ?? 0) === 0) {
+    if (!hasConflicts(change)) {
         // If there are no constraint violations, then tree changes apply.
         const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, idAllocator, fieldKinds);
         if (fieldDeltas.size > 0) {
@@ -1013,7 +1055,7 @@ function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
 exports.getChangeHandler = getChangeHandler;
-function newComposeTable(baseChange, newChange) {
+function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
         ...newCrossFieldTable(),
         baseChange,
@@ -1022,6 +1064,7 @@ function newComposeTable(baseChange, newChange) {
         newFieldToBaseField: new Map(),
         newToBaseNodeId: newTupleBTree(),
         composedNodes: new Set(),
+        composedNodeToParent,
         pendingCompositions: {
             nodeIdsToCompose: [],
             affectedBaseFields: newTupleBTree(),
@@ -1137,8 +1180,9 @@ class RebaseManager extends CrossFieldManagerI {
 }
 // TODO: Deduplicate this with RebaseTable
 class ComposeManager extends CrossFieldManagerI {
-    constructor(table, currentField, allowInval = true) {
+    constructor(table, currentField, fieldId, allowInval = true) {
         super(table, currentField, allowInval);
+        this.fieldId = fieldId;
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
@@ -1169,10 +1213,10 @@ class ComposeManager extends CrossFieldManagerI {
         super.set(target, revision, id, count, newValue, invalidateDependents);
     }
     onMoveIn(id) {
-        throw new Error("Method not implemented.");
+        setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        throw new Error("Method not implemented.");
+        throw new Error("Moving cross-field keys during compose is currently unsupported");
     }
     get table() {
         return this.crossFieldTable;
@@ -1231,14 +1275,18 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
      * @param content - The node(s) to build. Can be in either Field or Node mode.
      * @returns A description of the edit that can be passed to `submitChanges`.
      */
-    buildTrees(firstId, content) {
+    buildTrees(firstId, content, idCompressor) {
         if (content.mode === 1 /* CursorLocationType.Fields */ && content.getFieldLength() === 0) {
             return { type: "global" };
         }
         const builds = newTupleBTree();
+        const chunkCompressor = {
+            policy: index_js_3.defaultChunkPolicy,
+            idCompressor,
+        };
         const chunk = content.mode === 1 /* CursorLocationType.Fields */
-            ? (0, index_js_3.chunkFieldSingle)(content, index_js_3.defaultChunkPolicy)
-            : (0, index_js_3.chunkTree)(content, index_js_3.defaultChunkPolicy);
+            ? (0, index_js_3.chunkFieldSingle)(content, chunkCompressor)
+            : (0, index_js_3.chunkTree)(content, chunkCompressor);
         builds.set([undefined, firstId], chunk);
         return {
             type: "global",
@@ -1552,4 +1600,7 @@ function getFromChangeAtomIdMap(map, id) {
 function setInChangeAtomIdMap(map, id, value) {
     map.set([id.revision, id.localId], value);
 }
+function areEqualFieldIds(a, b) {
+    return (0, index_js_1.areEqualChangeAtomIdOpts)(a.nodeId, b.nodeId) && a.field === b.field;
+}
 //# sourceMappingURL=modularChangeFamily.js.map