@fluidframework/tree 2.81.0-374083 → 2.81.1

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -4,6 +4,8 @@
  */
 
 import { unreachableCase } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+
 import {
 	AnchorSet,
 	type DeltaDetachedNodeId,
@@ -11,7 +13,7 @@ import {
 	type IEditableForest,
 	type IForestSubscription,
 	type ReadOnlyDetachedFieldIndex,
-	type RevisionTag,
+	type TaggedChange,
 	type TreeStoredSchemaRepository,
 	tagChange,
 	visitDelta,
@@ -20,23 +22,33 @@ import {
 	type TreeChunk,
 	chunkTree,
 	defaultChunkPolicy,
-	getBuildsIds,
 	intoDelta,
 	relevantRemovedRoots,
 	updateRefreshers as updateDataChangeRefreshers,
 } from "../feature-libraries/index.js";
 import { disposeSymbol } from "../util/index.js";
+
 import { updateRefreshers } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type {
-	ChangeEnricherMutableCheckout,
-	ChangeEnricherReadonlyCheckout,
-} from "../shared-tree-core/index.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-export class SharedTreeReadonlyChangeEnricher
-	implements ChangeEnricherReadonlyCheckout<SharedTreeChange>
-{
+interface BorrowedState {
+	readonly forest: IForestSubscription;
+	readonly removedRoots: ReadOnlyDetachedFieldIndex;
+}
+
+interface OwnedState {
+	readonly forest: IEditableForest;
+	readonly removedRoots: DetachedFieldIndex;
+}
+
+export class SharedTreeChangeEnricher {
+	/**
+	 * Queue of changes to be applied before querying for detached roots.
+	 */
+	private readonly changeQueue: (() => TaggedChange<SharedTreeChange>)[] = [];
+	protected readonly borrowed: BorrowedState;
+	protected owned?: OwnedState;
+
 	/**
 	 * @param borrowedForest - The state based on which to enrich changes.
 	 * Not owned by the constructed instance.
@@ -44,92 +56,99 @@ export class SharedTreeReadonlyChangeEnricher
 	 * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.
 	 * Not owned by the constructed instance.
 	 * @param idCompressor - The id compressor to use when chunking trees.
+	 * @param onEnrichCommit - Optional callback invoked whenever a commit is enriched.
+	 * @param onRefresherAdded - Optional callback invoked whenever a refresher is added during enrichment.
+	 * @param onForkState - Optional callback invoked whenever the enricher forks its state.
+	 * @param onApplyChange - Optional callback invoked whenever a change is applied to the owned state.
 	 */
 	public constructor(
-		protected readonly borrowedForest: IForestSubscription,
+		borrowedForest: IForestSubscription,
+		borrowedRemovedRoots: ReadOnlyDetachedFieldIndex,
 		private readonly schema: TreeStoredSchemaRepository,
-		protected readonly borrowedRemovedRoots: ReadOnlyDetachedFieldIndex,
 		private readonly idCompressor?: IIdCompressor,
-	) {}
-
-	public fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {
-		return new SharedTreeMutableChangeEnricher(
-			this.borrowedForest.clone(this.schema, new AnchorSet()),
-			this.schema,
-			this.borrowedRemovedRoots.clone(),
-		);
+		private readonly onEnrichCommit?: () => void,
+		private readonly onRefresherAdded?: () => void,
+		private readonly onForkState?: () => void,
+		private readonly onApplyChange?: () => void,
+	) {
+		this.borrowed = {
+			forest: borrowedForest,
+			removedRoots: borrowedRemovedRoots,
+		};
 	}
 
-	public updateChangeEnrichments(change: SharedTreeChange): SharedTreeChange {
+	public enrich(change: SharedTreeChange): SharedTreeChange {
+		this.onEnrichCommit?.();
 		return updateRefreshers(
 			change,
-			getBuildsIds,
-			this.getDetachedRoot,
+			(id) => this.getDetachedRoot(id),
 			relevantRemovedRoots,
 			updateDataChangeRefreshers,
 		);
 	}
 
-	private readonly getDetachedRoot = (id: DeltaDetachedNodeId): TreeChunk | undefined => {
-		const root = this.borrowedRemovedRoots.tryGetEntry(id);
+	private getDetachedRoot(id: DeltaDetachedNodeId): TreeChunk | undefined {
+		this.purgeChangeQueue();
+		const state = this.owned ?? this.borrowed;
+		const root = state.removedRoots.tryGetEntry(id);
 		if (root !== undefined) {
-			const cursor = this.borrowedForest.getCursorAboveDetachedFields();
-			const parentField = this.borrowedRemovedRoots.toFieldKey(root);
+			const cursor = state.forest.getCursorAboveDetachedFields();
+			const parentField = state.removedRoots.toFieldKey(root);
 			cursor.enterField(parentField);
 			cursor.enterNode(0);
+			this.onRefresherAdded?.();
 			return chunkTree(cursor, {
 				policy: defaultChunkPolicy,
 				idCompressor: this.idCompressor,
 			});
 		}
 		return undefined;
-	};
-}
+	}
 
-export class SharedTreeMutableChangeEnricher
-	extends SharedTreeReadonlyChangeEnricher
-	implements ChangeEnricherMutableCheckout<SharedTreeChange>
-{
-	/**
-	 * @param forest - The state based on which to enrich changes.
-	 * Owned by the constructed instance.
-	 * @param schema - The schema that corresponds to the forest.
-	 * @param removedRoots - The set of removed roots based on which to enrich changes.
-	 * Owned by the constructed instance.
-	 * @param idCompressor - The id compressor to use when chunking trees.
-	 */
-	public constructor(
-		private readonly forest: IEditableForest,
-		schema: TreeStoredSchemaRepository,
-		private readonly removedRoots: DetachedFieldIndex,
-		idCompressor?: IIdCompressor,
-	) {
-		super(forest, schema, removedRoots, idCompressor);
+	public enqueueChange(
+		change: TaggedChange<SharedTreeChange> | (() => TaggedChange<SharedTreeChange>),
+	): void {
+		this.changeQueue.push(typeof change === "function" ? change : () => change);
 	}
 
-	public applyTipChange(change: SharedTreeChange, revision?: RevisionTag): void {
-		for (const dataOrSchemaChange of change.changes) {
-			const type = dataOrSchemaChange.type;
-			switch (type) {
-				case "data": {
-					const delta = intoDelta(tagChange(dataOrSchemaChange.innerChange, revision));
-					const visitor = this.forest.acquireVisitor();
-					visitDelta(delta, visitor, this.removedRoots, revision);
-					visitor.free();
-					break;
-				}
-				case "schema": {
-					// This enricher doesn't need to maintain schema information.
-					// Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using
-					// the schema that was used in the input context of the data changeset these refreshers are on.
-					// See the encoding logic in SharedTreeCore for details.
-					break;
-				}
-				default: {
-					unreachableCase(type);
+	private purgeChangeQueue(): void {
+		if (this.changeQueue.length === 0) {
+			return;
+		}
+		if (this.owned === undefined) {
+			this.onForkState?.();
+			this.owned = {
+				forest: this.borrowed.forest.clone(this.schema, new AnchorSet()),
+				removedRoots: this.borrowed.removedRoots.clone(),
+			};
+		}
+		for (const getChange of this.changeQueue) {
+			const { change, revision } = getChange();
+			this.onApplyChange?.();
+			for (const dataOrSchemaChange of change.changes) {
+				const type = dataOrSchemaChange.type;
+				switch (type) {
+					case "data": {
+						const delta = intoDelta(tagChange(dataOrSchemaChange.innerChange, revision));
+						const visitor = this.owned.forest.acquireVisitor();
+						visitDelta(delta, visitor, this.owned.removedRoots, revision);
+						visitor.free();
+						break;
+					}
+					case "schema": {
+						// This enricher doesn't need to maintain schema information.
+						// Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using
+						// the schema that was used in the input context of the data changeset these refreshers are on.
+						// See the encoding logic in SharedTreeCore for details.
+						break;
+					}
+					default: {
+						unreachableCase(type);
+					}
 				}
 			}
 		}
+		this.changeQueue.length = 0;
 	}
 
 	public [disposeSymbol](): void {

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -12,7 +12,6 @@ import {
 	type ChangeFamily,
 	type ChangeRebaser,
 	type DeltaDetachedNodeId,
-	type EditorOptions,
 	type RevisionMetadataSource,
 	type RevisionReplacer,
 	type RevisionTag,
@@ -40,7 +39,7 @@ import {
 
 import { makeSharedTreeChangeCodecFamily } from "./sharedTreeChangeCodecs.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import { IdBasedSharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 
 /**
  * Implementation of {@link ChangeFamily} that combines edits to fields and schema changes.
@@ -49,7 +48,7 @@ import { IdBasedSharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
  */
 export class SharedTreeChangeFamily
 	implements
-		ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+		ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
 		ChangeRebaser<SharedTreeChange>
 {
 	public static readonly emptyChange: SharedTreeChange = {
@@ -87,13 +86,11 @@ export class SharedTreeChangeFamily
 	public buildEditor(
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<SharedTreeChange>) => void,
-		options?: EditorOptions,
-	): IdBasedSharedTreeEditBuilder {
-		return new IdBasedSharedTreeEditBuilder(
+	): SharedTreeEditBuilder {
+		return new SharedTreeEditBuilder(
 			this.modularChangeFamily,
 			mintRevisionTag,
 			changeReceiver,
-			options,
 		);
 	}
 
@@ -272,7 +269,6 @@ function mapDataChanges(
  */
 export function updateRefreshers(
 	change: SharedTreeChange,
-	buildsFromDataChange: (taggedChange: ModularChangeset) => Iterable<DeltaDetachedNodeId>,
 	getDetachedNode: (id: DeltaDetachedNodeId) => TreeChunk | undefined,
 	relevantRemovedRootsFromDataChange: (
 		taggedChange: ModularChangeset,
@@ -319,19 +315,13 @@ export function updateRefreshers(
 	}
 	let isFirstDataChange = true;
 	return mapDataChanges(change, (dataChange) => {
-		const builtRoots = buildsFromDataChange(dataChange);
-		for (const id of builtRoots) {
-			// Detached root IDs that are used for builds are only ever used by a single node,
-			// so there is no risk of excluding needed refreshers by adding them to the list of already included roots.
-			addToNestedSet(includedRoots, id.major, id.minor);
-		}
 		const removedRoots = relevantRemovedRootsFromDataChange(dataChange);
 		if (isFirstDataChange) {
 			isFirstDataChange = false;
 			return updateDataChangeRefreshers(
 				dataChange,
 				getAndRememberDetachedNode,
-				filterIncludedRoots(removedRoots),
+				removedRoots,
 				true,
 			);
 		} else {

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -4,22 +4,14 @@
  */
 
 import type {
-	ChangeAtomId,
 	ChangeFamilyEditor,
-	EditorOptions,
 	RevisionTag,
 	TaggedChange,
-	TreeChunk,
 	TreeStoredSchema,
 } from "../core/index.js";
 import {
-	DefaultIdBasedDataEditor,
-	LocationBasedDataEditor,
-	type DetachedRootIds,
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
-	type Locator,
-	type DataEditor,
+	DefaultEditBuilder,
+	type IDefaultEditBuilder,
 	type ModularChangeFamily,
 } from "../feature-libraries/index.js";
 
@@ -41,16 +33,7 @@ export interface ISchemaEditor {
 /**
  * SharedTree editor for transactional tree data and schema changes.
  */
-export interface IIdBasedSharedTreeEditor
-	extends DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds> {
-	/**
-	 * Editor for schema changes.
-	 */
-	schema: ISchemaEditor;
-}
-
-export interface ILocationBasedSharedTreeEditor
-	extends DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation> {
+export interface ISharedTreeEditor extends IDefaultEditBuilder {
 	/**
 	 * Editor for schema changes.
 	 */
@@ -58,12 +41,12 @@ export interface ILocationBasedSharedTreeEditor
 }
 
 /**
- * Implementation of {@link DataEditor} based on the default set of supported field kinds.
+ * Implementation of {@link IDefaultEditBuilder} based on the default set of supported field kinds.
  * @sealed
  */
-export class IdBasedSharedTreeEditBuilder
-	extends DefaultIdBasedDataEditor
-	implements ChangeFamilyEditor, IIdBasedSharedTreeEditor
+export class SharedTreeEditBuilder
+	extends DefaultEditBuilder
+	implements ChangeFamilyEditor, ISharedTreeEditor
 {
 	public readonly schema: ISchemaEditor;
 
@@ -71,7 +54,6 @@ export class IdBasedSharedTreeEditBuilder
 		modularChangeFamily: ModularChangeFamily,
 		mintRevisionTag: () => RevisionTag,
 		private readonly changeReceiver: (change: TaggedChange<SharedTreeChange>) => void,
-		options?: EditorOptions,
 	) {
 		super(
 			modularChangeFamily,
@@ -81,13 +63,12 @@ export class IdBasedSharedTreeEditBuilder
 					...taggedChange,
 					change: { changes: [{ type: "data", innerChange: taggedChange.change }] },
 				}),
-			options,
 			modularChangeFamily.codecOptions,
 		);
 
 		this.schema = {
 			setStoredSchema: (oldSchema, newSchema) => {
-				changeReceiver({
+				this.changeReceiver({
 					revision: mintRevisionTag(),
 					change: {
 						changes: [
@@ -105,15 +86,3 @@ export class IdBasedSharedTreeEditBuilder
 		};
 	}
 }
-
-export class LocationBasedSharedTreeEditBuilder
-	extends LocationBasedDataEditor
-	implements ILocationBasedSharedTreeEditor
-{
-	public readonly schema: ISchemaEditor;
-
-	public constructor(idBasedEditor: IIdBasedSharedTreeEditor, locator: Locator) {
-		super(idBasedEditor, locator);
-		this.schema = idBasedEditor.schema;
-	}
-}

package/src/shared-tree/tree.ts

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { assert } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import { Context } from "../feature-libraries/index.js";
 import {
 	type ImplicitFieldSchema,
 	type TreeNode,
@@ -22,7 +23,6 @@ import {
 	SchematizingSimpleTreeView,
 } from "./schematizingTreeView.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
-import { Context } from "../feature-libraries/index.js";
 
 /**
  * Provides various functions for interacting with {@link TreeNode}s.
@@ -407,16 +407,16 @@ export interface RunTransaction {
 
 // TODO: Add more constraint types here
 
+/** A type-safe helper to add a "rollback" property (as required by the `RunTransaction` interface) to a given object */
+function defineRollbackProperty<T extends object>(
+	target: T,
+): T & { rollback: typeof rollback } {
+	Reflect.defineProperty(target, "rollback", { value: rollback });
+	return target as T & { readonly rollback: typeof rollback };
+}
+
 /** Creates a copy of `runTransaction` with the `rollback` property added so as to satisfy the `RunTransaction` interface. */
 function createRunTransaction(): RunTransaction {
-	/** A type-safe helper to add a "rollback" property (as required by the `RunTransaction` interface) to a given object */
-	function defineRollbackProperty<T extends object>(
-		target: T,
-	): T & { rollback: typeof rollback } {
-		Reflect.defineProperty(target, "rollback", { value: rollback });
-		return target as T & { readonly rollback: typeof rollback };
-	}
-
 	return defineRollbackProperty(runTransaction.bind({}));
 }
 

package/src/shared-tree/treeAlpha.ts

@@ -3,17 +3,40 @@
  * Licensed under the MIT License.
  */
 
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import {
 	assert,
 	debugAssert,
 	fail,
 	unreachableCase,
 } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor, SessionSpaceCompressedId } from "@fluidframework/id-compressor";
 import { createIdCompressor } from "@fluidframework/id-compressor/internal";
+import { isFluidHandle } from "@fluidframework/runtime-utils";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import type { IFluidHandle } from "@fluidframework/core-interfaces";
-import type { IIdCompressor, SessionSpaceCompressedId } from "@fluidframework/id-compressor";
 
+import {
+	FluidClientVersion,
+	type ICodecOptions,
+	type CodecWriteOptions,
+	FormatValidatorNoOp,
+} from "../codec/index.js";
+import { EmptyKey, type FieldKey, type ITreeCursorSynchronous } from "../core/index.js";
+import {
+	cursorForMapTreeField,
+	defaultSchemaPolicy,
+	isTreeValue,
+	makeFieldBatchCodec,
+	mapTreeFromCursor,
+	TreeCompressionStrategy,
+	type FieldBatch,
+	type FieldBatchEncodingContext,
+	type LocalNodeIdentifier,
+	type FlexTreeSequenceField,
+	type FlexTreeNode,
+	type Observer,
+	withObservation,
+} from "../feature-libraries/index.js";
 import {
 	asIndex,
 	getKernel,
@@ -62,31 +85,9 @@ import {
 	type TreeBranchAlpha,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
-import {
-	FluidClientVersion,
-	type ICodecOptions,
-	type CodecWriteOptions,
-	FormatValidatorNoOp,
-} from "../codec/index.js";
-import { EmptyKey, type FieldKey, type ITreeCursorSynchronous } from "../core/index.js";
-import {
-	cursorForMapTreeField,
-	defaultSchemaPolicy,
-	isTreeValue,
-	makeFieldBatchCodec,
-	mapTreeFromCursor,
-	TreeCompressionStrategy,
-	type FieldBatch,
-	type FieldBatchEncodingContext,
-	type LocalNodeIdentifier,
-	type FlexTreeSequenceField,
-	type FlexTreeNode,
-	type Observer,
-	withObservation,
-} from "../feature-libraries/index.js";
+
 import { independentInitializedView, type ViewContent } from "./independentView.js";
 import { SchematizingSimpleTreeView, ViewSlot } from "./schematizingTreeView.js";
-import { isFluidHandle } from "@fluidframework/runtime-utils";
 
 const identifier: TreeIdentifierUtils = (node: TreeNode): string | undefined => {
 	return getIdentifierFromNode(node, "uncompressed");