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

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

@@ -10,7 +10,7 @@ import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-for
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
 import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
-import { NodeExistenceState, } from "./fieldChangeHandler.js";
+import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { convertGenericChange, genericFieldKind, newGenericChangeset } from "./genericFieldKind.js";
 /**
@@ -18,9 +18,6 @@ import { convertGenericChange, genericFieldKind, newGenericChangeset } from "./g
  * as determined by the schema.
  */
 export class ModularChangeFamily {
-    codecs;
-    static emptyChange = makeModularChangeset();
-    fieldKinds;
     constructor(fieldKinds, codecs) {
         this.codecs = codecs;
         this.fieldKinds = fieldKinds;
@@ -270,14 +267,14 @@ export 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
                 ? tryGetFromNestedMap(change.nodeChanges, newId.revision, newId.localId)
                 : undefined;
             const baseNodeChange = baseId !== undefined
                 ? tryGetFromNestedMap(over.change.nodeChanges, baseId.revision, baseId.localId) ?? 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 ?? fail("Should not have two undefined IDs");
                 setInNestedMap(rebasedNodes, nodeId.revision, nodeId.localId, rebasedNode);
@@ -295,9 +292,10 @@ export class ModularChangeFamily {
                 context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (curr, base, existenceState) => curr ?? base, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
             }
         }
+        this.updateConstraintsForFields(rebasedFields, 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 = 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) {
@@ -307,8 +305,8 @@ export 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.
@@ -341,9 +339,9 @@ export class ModularChangeFamily {
                 const manager = newCrossFieldManager(crossFieldTable, fieldChange);
                 const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (child, baseChild) => {
                     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: brand(rebasedChangeset),
@@ -353,13 +351,13 @@ export class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    rebaseNodeChange(change, over, genId, crossFieldTable, revisionMetadata, constraintState, existenceState = 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;
@@ -367,19 +365,36 @@ export 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 === 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 === NodeAttachState.Detached || isDetached
+                    ? NodeAttachState.Detached
+                    : NodeAttachState.Attached;
+                this.updateConstraintsForNode(nodeId, attachState, constraintState, nodes);
+            }
+        }
+    }
+    updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
+        const node = tryGetFromNestedMap(nodes, nodeId.revision, nodeId.localId) ?? fail("Unknown node ID");
+        if (node.nodeExistsConstraint !== undefined) {
+            const isNowViolated = attachState === 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();
@@ -466,6 +481,7 @@ export class ModularChangeFamily {
         return new ModularEditBuilder(this, changeReceiver);
     }
 }
+ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
@@ -830,10 +846,9 @@ function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined,
     return changeset;
 }
 export class ModularEditBuilder extends EditBuilder {
-    transactionDepth = 0;
-    idAllocator;
     constructor(family, changeReceiver) {
         super(family, changeReceiver);
+        this.transactionDepth = 0;
         this.idAllocator = idAllocatorFromMaxId();
     }
     enterTransaction() {