@fluidframework/tree 2.4.0-294316 → 2.4.0-297027

package/src/core/schema-stored/schema.ts

@@ -166,6 +166,11 @@ export abstract class TreeNodeStoredSchema {
 	 * and is runtime validated by the codec.
 	 */
 	public abstract encode(): ErasedTreeNodeSchemaDataFormat;
+
+	/**
+	 * Returns the schema for the provided field.
+	 */
+	public abstract getFieldSchema(field: FieldKey): TreeFieldStoredSchema;
 }
 
 /**
@@ -202,6 +207,10 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 			object: fieldsObject,
 		});
 	}
+
+	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
+		return this.objectNodeFields.get(field) ?? storedEmptyFieldSchema;
+	}
 }
 
 /**
@@ -225,6 +234,10 @@ export class MapNodeStoredSchema extends TreeNodeStoredSchema {
 			map: encodeFieldSchema(this.mapFields),
 		});
 	}
+
+	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
+		return this.mapFields;
+	}
 }
 
 /**
@@ -252,6 +265,10 @@ export class LeafNodeStoredSchema extends TreeNodeStoredSchema {
 			leaf: encodeValueSchema(this.leafValue),
 		});
 	}
+
+	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
+		return storedEmptyFieldSchema;
+	}
 }
 
 export const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<

package/src/core/tree/anchorSet.ts

@@ -128,7 +128,6 @@ export interface AnchorEvents {
 	 * Compare to {@link AnchorEvents.childrenChanged} which is emitted in the middle of the batch/delta-visit.
 	 */
 	childrenChangedAfterBatch(arg: {
-		anchor: AnchorNode;
 		changedFields: ReadonlySet<FieldKey>;
 	}): void;
 
@@ -179,7 +178,7 @@ export interface AnchorEvents {
 	 * subtree changed, compared to {@link AnchorEvents.subtreeChanged} or {@link AnchorEvents.subtreeChanging} which
 	 * fire when something _may_ have changed or _may_ be about to change.
 	 */
-	subtreeChangedAfterBatch(anchor: AnchorNode): void;
+	subtreeChangedAfterBatch(): void;
 }
 
 /**
@@ -775,9 +774,9 @@ export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator
 									e.changedField ??
 									fail("childrenChangedAfterBatch events should have a changedField"),
 							);
-						node.events.emit(event, { anchor: node, changedFields: new Set(fieldKeys) });
+						node.events.emit(event, { changedFields: new Set(fieldKeys) });
 					} else {
-						node.events.emit(event, node);
+						node.events.emit(event);
 					}
 				}
 			},

package/src/core/tree/detachedFieldIndex.ts

@@ -150,7 +150,15 @@ export class DetachedFieldIndex {
 					});
 				}
 				this.latestRelevantRevisionToFields.delete(current);
-				this.latestRelevantRevisionToFields.set(updated, inner);
+
+				const updatedInner = this.latestRelevantRevisionToFields.get(updated);
+				if (updatedInner !== undefined) {
+					for (const [root, nodeId] of inner) {
+						updatedInner.set(root, nodeId);
+					}
+				} else {
+					this.latestRelevantRevisionToFields.set(updated, inner);
+				}
 			}
 		}
 
@@ -349,10 +357,13 @@ export class DetachedFieldIndex {
 			0x9bd /* revisions should only be set once using this function after loading data from a summary */,
 		);
 
-		const newDetachedNodeToField = new Map();
+		const newDetachedNodeToField: NestedMap<Major, Minor, DetachedField> = new Map();
 		const rootMap = new Map();
 		forEachInNestedMap(this.detachedNodeToField, ({ root }, major, minor) => {
-			setInNestedMap(newDetachedNodeToField, major, minor, { root, latestRevision });
+			setInNestedMap(newDetachedNodeToField, major, minor, {
+				root,
+				latestRelevantRevision: latestRevision,
+			});
 			rootMap.set(root, { major, minor });
 		});
 

package/src/core/tree/detachedFieldIndexTypes.ts

@@ -27,7 +27,7 @@ export type ForestRootId = Brand<number, "tree.ForestRootId">;
 export interface DetachedField {
 	/**
 	 * The atomic ID that the `DetachedFieldIndex` uses to uniquely identify the first (and only) root in the field.
-	 * This ID is scoped to the specific `DetachedFieldIndex` from witch this object was retrieved.
+	 * This ID is scoped to the specific `DetachedFieldIndex` from which this object was retrieved.
 	 *
 	 * The current implementation only supports a single root per field.
 	 * This will be changed in the future for performance reasons.