@fluidframework/tree 2.21.0 → 2.23.0-323641

package/src/core/tree/anchorSet.ts

@@ -18,23 +18,15 @@ import {
 	brand,
 	brandedSlot,
 	fail,
+	getOrAddEmptyToMap,
+	getOrCreate,
 } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type * as Delta from "./delta.js";
-import type {
-	DetachedPlaceUpPath,
-	DetachedRangeUpPath,
-	PlaceIndex,
-	PlaceUpPath,
-	Range,
-	RangeUpPath,
-	UpPath,
-} from "./pathTree.js";
+import type { PlaceIndex, Range, UpPath } from "./pathTree.js";
 import { EmptyKey } from "./types.js";
 import type { DeltaVisitor } from "./visitDelta.js";
-import type { PathVisitor } from "./visitPath.js";
-import type { AnnouncedVisitor } from "./visitorUtils.js";
 
 /**
  * A way to refer to a particular tree location within an {@link AnchorSet}.
@@ -137,10 +129,9 @@ export interface AnchorEvents {
 	 * rooted at `anchor` _may_ be about to change due to updates from the batch.
 	 *
 	 * @remarks
-	 * The event can optionally return a {@link PathVisitor} to traverse the subtree.
 	 * Called on every parent (transitively) when a change is occurring.
 	 */
-	subtreeChanging(anchor: AnchorNode): PathVisitor | void;
+	subtreeChanging(anchor: AnchorNode): void;
 
 	/**
 	 * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if something in the subtree
@@ -689,7 +680,7 @@ export class AnchorSet implements AnchorLocator {
 	 * It is invalid to acquire a visitor without releasing the previous one,
 	 * and this method will throw an error if this is attempted.
 	 */
-	public acquireVisitor(): AnnouncedVisitor & DeltaVisitor {
+	public acquireVisitor(): DeltaVisitor {
 		assert(
 			this.activeVisitor === undefined,
 			0x767 /* Must release existing visitor before acquiring another */,
@@ -716,25 +707,13 @@ export class AnchorSet implements AnchorLocator {
 					}
 				}
 			},
-			// Lookup table for path visitors collected from {@link AnchorEvents.visitSubtreeChanging} emitted events.
-			// The key is the path of the node that the visitor is registered on. The code ensures that the path visitor visits only the appropriate subtrees
-			// by maintaining the mapping only during time between the {@link DeltaVisitor.enterNode} and {@link DeltaVisitor.exitNode} calls for a given anchorNode.
-			pathVisitors: new Map<PathNode, Set<PathVisitor>>(),
 			parentField: undefined as FieldKey | undefined,
 			parent: undefined as UpPath | undefined,
 
 			/**
 			 * Events collected during the visit which get sent as a batch during "free".
 			 */
-			bufferedEvents: [] as {
-				node: PathNode;
-				event: keyof AnchorEvents;
-				/**
-				 * The key for the impacted field, if the event is associated with a key.
-				 * Some events, such as afterDestroy, do not involve a key, and thus leave this undefined.
-				 */
-				changedField?: FieldKey;
-			}[],
+			bufferedEvents: [] as BufferedEvent[],
 
 			// 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
 			// subtreeChangedAfterBatch events.
@@ -766,25 +745,31 @@ export class AnchorSet implements AnchorLocator {
 					node.removeRef();
 				}
 				this.anchorSet.activeVisitor = undefined;
-				const alreadyEmitted = new Map<PathNode, string[]>();
-				for (const { node, event } of this.bufferedEvents) {
-					if (!alreadyEmitted.has(node)) {
-						alreadyEmitted.set(node, []);
+
+				// Aggregate changedFields by node.
+				const eventsByNode: Map<PathNode, Set<FieldKey>> = new Map();
+				for (const { node, event, changedField } of this.bufferedEvents) {
+					if (event === "childrenChangedAfterBatch") {
+						const keys = getOrCreate(eventsByNode, node, () => new Set());
+						keys.add(
+							changedField ??
+								fail("childrenChangedAfterBatch events should have a changedField"),
+						);
 					}
-					const emittedEvents = alreadyEmitted.get(node);
-					if (emittedEvents?.includes(event) ?? false) {
+				}
+
+				const alreadyEmitted = new Map<PathNode, (keyof AnchorEvents)[]>();
+				for (const { node, event } of this.bufferedEvents) {
+					const emittedEvents = getOrAddEmptyToMap(alreadyEmitted, node);
+					if (emittedEvents.includes(event)) {
 						continue;
 					}
-					emittedEvents?.push(event);
+					emittedEvents.push(event);
 					if (event === "childrenChangedAfterBatch") {
-						const fieldKeys: FieldKey[] = this.bufferedEvents
-							.filter((e) => e.node === node && e.event === event)
-							.map(
-								(e) =>
-									e.changedField ??
-									fail("childrenChangedAfterBatch events should have a changedField"),
-							);
-						node.events.emit(event, { changedFields: new Set(fieldKeys) });
+						const changedFields =
+							eventsByNode.get(node) ??
+							fail("childrenChangedAfterBatch events should have changedFields");
+						node.events.emit(event, { changedFields });
 					} else {
 						node.events.emit(event);
 					}
@@ -813,47 +798,6 @@ export class AnchorSet implements AnchorLocator {
 					() => {},
 				);
 			},
-			beforeAttach(source: FieldKey, count: number, destination: PlaceIndex): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a0 /* Must be in a field in order to attach */,
-				);
-				const destinationPath: PlaceUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					index: destination,
-				};
-				const sourcePath: DetachedRangeUpPath = brand({
-					field: source,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeAttach(sourcePath, destinationPath);
-					}
-				}
-			},
-			afterAttach(source: FieldKey, destination: Range): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a1 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: DetachedPlaceUpPath = brand({
-					field: source,
-					index: 0,
-				});
-				const destinationPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...destination,
-				};
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterAttach(sourcePath, destinationPath);
-					}
-				}
-			},
 			attach(source: FieldKey, count: number, destination: PlaceIndex): void {
 				this.notifyChildrenChanging();
 				this.attachEdit(source, count, destination);
@@ -877,47 +821,6 @@ export class AnchorSet implements AnchorLocator {
 				this.anchorSet.moveChildren(sourcePath, destinationPath, count);
 				this.depthThresholdForSubtreeChanged = this.currentDepth;
 			},
-			beforeDetach(source: Range, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a3 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...source,
-				};
-				const destinationPath: DetachedPlaceUpPath = brand({
-					field: destination,
-					index: 0,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeDetach(sourcePath, destinationPath);
-					}
-				}
-			},
-			afterDetach(source: PlaceIndex, count: number, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a4 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: PlaceUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					index: source,
-				};
-				const destinationPath: DetachedRangeUpPath = brand({
-					field: destination,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterDetach(sourcePath, destinationPath);
-					}
-				}
-			},
 			detach(source: Range, destination: FieldKey): void {
 				this.notifyChildrenChanging();
 				this.detachEdit(source, destination);
@@ -941,64 +844,6 @@ export class AnchorSet implements AnchorLocator {
 				this.anchorSet.moveChildren(sourcePath, destinationPath, source.end - source.start);
 				this.depthThresholdForSubtreeChanged = this.currentDepth;
 			},
-			beforeReplace(newContent: FieldKey, oldContent: Range, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a6 /* Must be in a field in order to replace */,
-				);
-				const oldContentPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...oldContent,
-				};
-				const newNodesSourcePath: DetachedRangeUpPath = brand({
-					field: newContent,
-					start: 0,
-					end: oldContent.end - oldContent.start,
-				});
-				const oldNodesDestinationPath: DetachedPlaceUpPath = brand({
-					field: destination,
-					index: 0,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeReplace(
-							newNodesSourcePath,
-							oldContentPath,
-							oldNodesDestinationPath,
-						);
-					}
-				}
-			},
-			afterReplace(newContentSource: FieldKey, newContent: Range, oldContent: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a7 /* Must be in a field in order to replace */,
-				);
-				const newContentPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...newContent,
-				};
-				const newNodesSourcePath: DetachedPlaceUpPath = brand({
-					field: newContentSource,
-					index: 0,
-				});
-				const oldNodesDestinationPath: DetachedRangeUpPath = brand({
-					field: oldContent,
-					start: 0,
-					end: newContent.end - newContent.start,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterReplace(
-							newNodesSourcePath,
-							newContentPath,
-							oldNodesDestinationPath,
-						);
-					}
-				}
-			},
 			replace(
 				newContentSource: FieldKey,
 				range: Range,
@@ -1019,34 +864,10 @@ export class AnchorSet implements AnchorLocator {
 					count,
 				);
 			},
-			beforeDestroy(detachedField: FieldKey, count: number): void {
-				const range: DetachedRangeUpPath = brand({
-					field: detachedField,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeDestroy(range);
-					}
-				}
-			},
 			create(content: Delta.ProtoNodes, destination: FieldKey): void {
 				// Nothing to do since content can only be created in a new detached field,
 				// which cannot contain any anchors.
 			},
-			afterCreate(content: Delta.ProtoNodes, destination: FieldKey): void {
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						const rangePath: DetachedRangeUpPath = brand({
-							field: destination,
-							start: 0,
-							end: content.length,
-						});
-						pathVisitor.afterCreate(rangePath);
-					}
-				}
-			},
 			enterNode(index: number): void {
 				assert(this.parentField !== undefined, 0x3ab /* Must be in a field to enter node */);
 
@@ -1057,19 +878,7 @@ export class AnchorSet implements AnchorLocator {
 				};
 				this.parentField = undefined;
 				this.maybeWithNode((p) => {
-					// avoid multiple pass side-effects
-					if (!this.pathVisitors.has(p)) {
-						const visitors: (PathVisitor | void)[] = p.events.emitAndCollect(
-							"subtreeChanging",
-							p,
-						);
-						if (visitors.length > 0) {
-							this.pathVisitors.set(
-								p,
-								new Set(visitors.filter((v): v is PathVisitor => v !== undefined)),
-							);
-						}
-					}
+					p.events.emit("subtreeChanging", p);
 				});
 				this.currentDepth++;
 			},
@@ -1084,8 +893,6 @@ export class AnchorSet implements AnchorLocator {
 						});
 						this.depthThresholdForSubtreeChanged--;
 					}
-					// Remove subtree path visitors added at this node if there are any
-					this.pathVisitors.delete(p);
 				});
 				const parent = this.parent;
 				this.parentField = parent.parentField;
@@ -1387,3 +1194,13 @@ function binaryFind(sorted: readonly PathNode[], index: number): PathNode | unde
 	}
 	return undefined; // If we reach here, target is not in array (or array was not sorted)
 }
+
+interface BufferedEvent {
+	node: PathNode;
+	event: keyof AnchorEvents;
+	/**
+	 * The key for the impacted field, if the event is associated with a key.
+	 * Some events, such as afterDestroy, do not involve a key, and thus leave this undefined.
+	 */
+	changedField?: FieldKey;
+}

package/src/core/tree/index.ts

@@ -55,8 +55,6 @@ export {
 	type PlaceUpPath,
 	type PlaceIndex,
 	type NodeIndex,
-	type DetachedPlaceUpPath,
-	type DetachedRangeUpPath,
 	compareUpPaths,
 	compareFieldUpPaths,
 	getDetachedFieldContainingPath,
@@ -98,7 +96,6 @@ export {
 	combineVisitors,
 	makeDetachedFieldIndex,
 } from "./visitorUtils.js";
-export type { PathVisitor } from "./visitPath.js";
 
 export { SparseNode, getDescendant } from "./sparseTree.js";
 

package/src/core/tree/pathTree.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { Brand } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import { type DetachedField, keyAsDetachedField } from "./types.js";
@@ -60,13 +59,6 @@ export interface FieldUpPath<TUpPath extends UpPath = UpPath> {
 	readonly field: FieldKey; // TODO: Type information, including when in DetachedField.
 }
 
-/**
- * A range of nodes in a detached field.
- * Unlike RangeUpPath, such ranges are generated by create and detach operations,
- * as well as consumed by destroy and attach operations.
- */
-export type DetachedRangeUpPath = Brand<Omit<RangeUpPath, "parent">, "DetachedRangeUpPath">;
-
 /**
  * Delimits the extend of a range.
  */
@@ -101,11 +93,6 @@ export interface PlaceUpPath<TUpPath extends UpPath = UpPath> extends FieldUpPat
 	readonly index: PlaceIndex;
 }
 
-/**
- * A place in a detached field.
- */
-export type DetachedPlaceUpPath = Brand<Omit<PlaceUpPath, "parent">, "DetachedRangeUpPath">;
-
 /**
  * Indicates the index of a node in a field.
  * Zero indicates the first node in a field.

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -42,7 +42,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 		rebase: (change: 0, over: 0) => 0,
 	}),
 	codecsFactory: () => noChangeCodecFamily,
-	editor: { buildChildChange: (index, change) => fail("Child changes not supported") },
+	editor: { buildChildChanges: () => fail("Child changes not supported") },
 	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
 	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,

package/src/feature-libraries/detachedFieldIndexSummarizer.ts

@@ -6,7 +6,6 @@
 import { bufferToString } from "@fluid-internal/client-utils";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
-	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -52,16 +51,6 @@ export class DetachedFieldIndexSummarizer implements Summarizable {
 		return this.getAttachSummary(stringify, fullTree, trackState, telemetryContext);
 	}
 
-	public getGCData(fullGC?: boolean): IGarbageCollectionData {
-		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
-		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
-		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
-		// blob.
-		return {
-			gcNodes: {},
-		};
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/feature-libraries/flex-tree/treeEvents.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { PathVisitor, UpPath } from "../../core/index.js";
+import type { UpPath } from "../../core/index.js";
 
 /**
  * This file provides an API for working with trees which is type safe even when schema is not known.
@@ -39,13 +39,11 @@ export interface FlexTreeNodeEvents {
 
 	/**
 	 * Raised when something in the tree is changing, including this node and its descendants.
-	 * The event can optionally return a {@link PathVisitor} to traverse the subtree
 	 * This event is called on every parent (transitively) when a change is occurring.
 	 * Includes changes to this node itself.
 	 * @param upPath - the path corresponding to the location of the node being changed, upward.
-	 * @returns a visitor to traverse the subtree or `void`.
 	 */
-	subtreeChanging(upPath: UpPath): PathVisitor | void;
+	subtreeChanging(upPath: UpPath): void;
 
 	/**
 	 * This has the same contract as {@link TreeChangeEvents.nodeChanged}

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -7,7 +7,6 @@ import { bufferToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
-	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -114,16 +113,6 @@ export class ForestSummarizer implements Summarizable {
 		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
 	}
 
-	public getGCData(fullGC?: boolean): IGarbageCollectionData {
-		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
-		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
-		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
-		// blob.
-		return {
-			gcNodes: {},
-		};
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/feature-libraries/modular-schema/fieldChangeHandler.ts

@@ -201,9 +201,13 @@ export function isolatedFieldChangeRebaser<TChangeset>(data: {
 
 export interface FieldEditor<TChangeset> {
 	/**
-	 * Creates a changeset which represents the given `change` to the child at `childIndex` of this editor's field.
+	 * Creates a changeset which represents the given changes to the children of this editor's field.
+	 * For each element in the given iterable
+	 * - The number represents the index of the child node in the field.
+	 * - The `NodeId` represents the nested changes for that child node.
+	 * Note: The indices in the iterable must be ordered from smallest to largest (with no duplicates).
 	 */
-	buildChildChange(childIndex: number, change: NodeId): TChangeset;
+	buildChildChanges(changes: Iterable<[index: number, change: NodeId]>): TChangeset;
 }
 
 /**

package/src/feature-libraries/modular-schema/genericFieldKind.ts

@@ -6,14 +6,11 @@
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
-	type RevisionMetadataSource,
 	Multiplicity,
 	type RevisionTag,
 	replaceAtomRevisions,
 } from "../../core/index.js";
-import { type IdAllocator, fail } from "../../util/index.js";
 import { assert } from "@fluidframework/core-utils/internal";
-import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type {
 	FieldChangeDelta,
 	FieldChangeHandler,
@@ -43,8 +40,8 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 	},
 	codecsFactory: makeGenericChangeCodec,
 	editor: {
-		buildChildChange(index, change): GenericChangeset {
-			return newGenericChangeset([[index, change]]);
+		buildChildChanges(changes: Iterable<[number, NodeId]>): GenericChangeset {
+			return newGenericChangeset(Array.from(changes));
 		},
 	},
 	intoDelta: (change: GenericChangeset, deltaFromChild: ToDelta): FieldChangeDelta => {
@@ -182,39 +179,10 @@ export const genericFieldKind: FieldKindWithEditor = new FieldKindWithEditor(
 export function convertGenericChange<TChange>(
 	changeset: GenericChangeset,
 	target: FieldChangeHandler<TChange>,
-	composeChild: NodeChangeComposer,
-	genId: IdAllocator,
-	revisionMetadata: RevisionMetadataSource,
 ): TChange {
-	const perIndex: TChange[] = [];
-	for (const [index, nodeChange] of changeset.entries()) {
-		perIndex.push(target.editor.buildChildChange(index, nodeChange));
-	}
-
-	if (perIndex.length === 0) {
-		return target.createEmpty();
-	}
-
-	return perIndex.reduce((a, b) =>
-		target.rebaser.compose(
-			a,
-			b,
-			composeChild,
-			genId,
-			invalidCrossFieldManager,
-			revisionMetadata,
-		),
-	);
+	return target.editor.buildChildChanges(changeset.entries());
 }
 
-const invalidFunc = (): never => fail("Should not be called when converting generic changes");
-const invalidCrossFieldManager: CrossFieldManager = {
-	set: invalidFunc,
-	get: invalidFunc,
-	onMoveIn: invalidFunc,
-	moveKey: invalidFunc,
-};
-
 function* relevantRemovedRoots(
 	change: GenericChangeset,
 	relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,