@fluidframework/tree 2.0.0-dev-rc.5.0.0.271262 → 2.0.0-dev-rc.5.0.0.272251

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

@@ -21,9 +21,6 @@ const genericFieldKind_js_1 = require("./genericFieldKind.js");
  * as determined by the schema.
  */
 class ModularChangeFamily {
-    codecs;
-    static emptyChange = makeModularChangeset();
-    fieldKinds;
     constructor(fieldKinds, codecs) {
         this.codecs = codecs;
         this.fieldKinds = fieldKinds;
@@ -273,14 +270,14 @@ class ModularChangeFamily {
         };
         const rebasedFields = this.rebaseFieldMap(change.fieldChanges, over.change.fieldChanges, genId, crossFieldTable, rebaseMetadata);
         const rebasedNodes = new Map();
-        for (const [newId, baseId, existenceState] of crossFieldTable.nodeIdPairs) {
+        for (const [newId, baseId] of crossFieldTable.nodeIdPairs) {
             const newNodeChange = newId !== undefined
                 ? (0, index_js_2.tryGetFromNestedMap)(change.nodeChanges, newId.revision, newId.localId)
                 : undefined;
             const baseNodeChange = baseId !== undefined
                 ? (0, index_js_2.tryGetFromNestedMap)(over.change.nodeChanges, baseId.revision, baseId.localId) ?? (0, index_js_2.fail)("Unknown node ID")
                 : {};
-            const rebasedNode = this.rebaseNodeChange(newNodeChange, baseNodeChange, genId, crossFieldTable, rebaseMetadata, constraintState, existenceState);
+            const rebasedNode = this.rebaseNodeChange(newNodeChange, baseNodeChange, genId, crossFieldTable, rebaseMetadata);
             if (rebasedNode !== undefined) {
                 const nodeId = newId ?? baseId ?? (0, index_js_2.fail)("Should not have two undefined IDs");
                 (0, index_js_2.setInNestedMap)(rebasedNodes, nodeId.revision, nodeId.localId, rebasedNode);
@@ -298,9 +295,10 @@ class ModularChangeFamily {
                 context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (curr, base, existenceState) => curr ?? base, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
             }
         }
+        this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes);
         return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
     }
-    rebaseFieldMap(change, over, genId, crossFieldTable, revisionMetadata, existenceState = fieldChangeHandler_js_1.NodeExistenceState.Alive) {
+    rebaseFieldMap(change, over, genId, crossFieldTable, revisionMetadata) {
         const rebasedFields = new Map();
         // Rebase fields contained in the base changeset
         for (const [field, baseChanges] of over) {
@@ -310,8 +308,8 @@ class ModularChangeFamily {
             };
             const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChanges, genId, revisionMetadata);
             const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-            const rebaseChild = (child, baseChild, stateChange) => {
-                crossFieldTable.nodeIdPairs.push([child, baseChild, stateChange]);
+            const rebaseChild = (child, baseChild, _attachState) => {
+                crossFieldTable.nodeIdPairs.push([child, baseChild]);
                 return (child ??
                     // The fact `child` is undefined means that the changeset to rebase does not include changes for
                     // this node or its descendants. However, it's possible that it will after rebasing.
@@ -344,9 +342,9 @@ class ModularChangeFamily {
                 const manager = newCrossFieldManager(crossFieldTable, fieldChange);
                 const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (child, baseChild) => {
                     (0, internal_1.assert)(baseChild === undefined, 0x5b6 /* This field should not have any base changes */);
-                    crossFieldTable.nodeIdPairs.push([child, undefined, existenceState]);
+                    crossFieldTable.nodeIdPairs.push([child, undefined]);
                     return child;
-                }, genId, manager, revisionMetadata, existenceState);
+                }, genId, manager, revisionMetadata);
                 const rebasedFieldChange = {
                     fieldKind: fieldKind.identifier,
                     change: (0, index_js_2.brand)(rebasedChangeset),
@@ -356,13 +354,13 @@ class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    rebaseNodeChange(change, over, genId, crossFieldTable, revisionMetadata, constraintState, existenceState = fieldChangeHandler_js_1.NodeExistenceState.Alive) {
+    rebaseNodeChange(change, over, genId, crossFieldTable, revisionMetadata) {
         const key = change ?? over;
         if (key === undefined) {
             return undefined;
         }
         const baseMap = over?.fieldChanges ?? new Map();
-        const fieldChanges = this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, genId, crossFieldTable, revisionMetadata, existenceState);
+        const fieldChanges = this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, genId, crossFieldTable, revisionMetadata);
         const rebasedChange = {};
         if (fieldChanges.size > 0) {
             rebasedChange.fieldChanges = fieldChanges;
@@ -370,19 +368,36 @@ class ModularChangeFamily {
         if (change?.nodeExistsConstraint !== undefined) {
             rebasedChange.nodeExistsConstraint = change.nodeExistsConstraint;
         }
-        // If there's a node exists constraint and we removed or revived the node, update constraint state
-        if (rebasedChange.nodeExistsConstraint !== undefined) {
-            const violatedAfter = existenceState === fieldChangeHandler_js_1.NodeExistenceState.Dead;
-            if (rebasedChange.nodeExistsConstraint.violated !== violatedAfter) {
-                rebasedChange.nodeExistsConstraint = {
-                    ...rebasedChange.nodeExistsConstraint,
-                    violated: violatedAfter,
+        crossFieldTable.rebasedNodeCache.set(key, rebasedChange);
+        return rebasedChange;
+    }
+    updateConstraintsForFields(fields, parentAttachState, constraintState, nodes) {
+        for (const field of fields.values()) {
+            const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
+            for (const [nodeId, index] of handler.getNestedChanges(field.change)) {
+                const isDetached = index === undefined;
+                const attachState = parentAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached || isDetached
+                    ? fieldChangeHandler_js_1.NodeAttachState.Detached
+                    : fieldChangeHandler_js_1.NodeAttachState.Attached;
+                this.updateConstraintsForNode(nodeId, attachState, constraintState, nodes);
+            }
+        }
+    }
+    updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
+        const node = (0, index_js_2.tryGetFromNestedMap)(nodes, nodeId.revision, nodeId.localId) ?? (0, index_js_2.fail)("Unknown node ID");
+        if (node.nodeExistsConstraint !== undefined) {
+            const isNowViolated = attachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
+            if (node.nodeExistsConstraint.violated !== isNowViolated) {
+                node.nodeExistsConstraint = {
+                    ...node.nodeExistsConstraint,
+                    violated: isNowViolated,
                 };
-                constraintState.violationCount += violatedAfter ? 1 : -1;
+                constraintState.violationCount += isNowViolated ? 1 : -1;
             }
         }
-        crossFieldTable.rebasedNodeCache.set(key, rebasedChange);
-        return rebasedChange;
+        if (node.fieldChanges !== undefined) {
+            this.updateConstraintsForFields(node.fieldChanges, attachState, constraintState, nodes);
+        }
     }
     pruneFieldMap(changeset, nodeMap) {
         const prunedChangeset = new Map();
@@ -470,6 +485,7 @@ class ModularChangeFamily {
     }
 }
 exports.ModularChangeFamily = ModularChangeFamily;
+ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
@@ -840,10 +856,9 @@ function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined,
     return changeset;
 }
 class ModularEditBuilder extends index_js_1.EditBuilder {
-    transactionDepth = 0;
-    idAllocator;
     constructor(family, changeReceiver) {
         super(family, changeReceiver);
+        this.transactionDepth = 0;
         this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
     }
     enterTransaction() {