@fluidframework/tree 2.80.0 → 2.81.0

package/src/shared-tree/schematizingTreeView.ts

@@ -294,17 +294,16 @@ export class SchematizingSimpleTreeView<
 			| void,
 		params?: RunTransactionParams,
 	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
-		const addConstraints = (
-			constraintsOnRevert: boolean,
-			constraints: readonly TransactionConstraintAlpha[] = [],
-		): void => {
-			addConstraintsToTransaction(this.checkout, constraintsOnRevert, constraints);
-		};
+		const { checkout } = this;
 
-		this.checkout.transaction.start();
+		checkout.transaction.start();
 
 		// Validate preconditions before running the transaction callback.
-		addConstraints(false /* constraintsOnRevert */, params?.preconditions);
+		addConstraintsToTransaction(
+			checkout,
+			false /* constraintsOnRevert */,
+			params?.preconditions,
+		);
 		const transactionCallbackStatus = transaction();
 		const rollback = transactionCallbackStatus?.rollback;
 		const value = (
@@ -312,19 +311,20 @@ export class SchematizingSimpleTreeView<
 		)?.value;
 
 		if (rollback === true) {
-			this.checkout.transaction.abort();
+			checkout.transaction.abort();
 			return value === undefined
 				? { success: false }
 				: { success: false, value: value as TFailureValue };
 		}
 
 		// Validate preconditions on revert after running the transaction callback and was successful.
-		addConstraints(
+		addConstraintsToTransaction(
+			checkout,
 			true /* constraintsOnRevert */,
 			transactionCallbackStatus?.preconditionsOnRevert,
 		);
 
-		this.checkout.transaction.commit();
+		checkout.transaction.commit();
 		return value === undefined
 			? { success: true }
 			: { success: true, value: value as TSuccessValue };
@@ -455,7 +455,9 @@ export class SchematizingSimpleTreeView<
 			this.flexTreeContext[disposeSymbol]();
 			this.flexTreeContext = undefined;
 		}
-		this.flexTreeViewUnregisterCallbacks.forEach((unregister) => unregister());
+		for (const unregister of this.flexTreeViewUnregisterCallbacks) {
+			unregister();
+		}
 		this.flexTreeViewUnregisterCallbacks.clear();
 		anchors.slots.delete(SimpleContextSlot);
 	}
@@ -470,7 +472,9 @@ export class SchematizingSimpleTreeView<
 	public dispose(): void {
 		this.disposed = true;
 		this.disposeFlexView();
-		this.unregisterCallbacks.forEach((unregister) => unregister());
+		for (const unregister of this.unregisterCallbacks) {
+			unregister();
+		}
 		this.checkout.forest.anchors.slots.delete(ViewSlot);
 		this.currentCompatibility = undefined;
 		this.onDispose?.();

package/src/shared-tree/sharedTree.ts

@@ -98,13 +98,6 @@ import {
 	type SimpleAllowedTypeAttributes,
 	type SchemaType,
 } from "../simple-tree/index.js";
-
-import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import { SharedTreeReadonlyChangeEnricher } from "./sharedTreeChangeEnricher.js";
-import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
-import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
-import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
 import {
 	brand,
 	type Breakable,
@@ -112,10 +105,16 @@ import {
 	type JsonCompatible,
 	throwIfBroken,
 } from "../util/index.js";
+
+import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import {
 	getCodecTreeForChangeFormat,
 	type SharedTreeChangeFormatVersion,
 } from "./sharedTreeChangeCodecs.js";
+import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
+import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
+import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
 
 /**
  * Copy of data from an {@link ITreePrivate} at some point in time.
@@ -296,7 +295,6 @@ export class SharedTreeKernel
 				throw error;
 			},
 		);
-		const changeEnricher = new SharedTreeReadonlyChangeEnricher(forest, schema, removedRoots);
 		super(
 			breaker,
 			sharedObject,
@@ -311,8 +309,6 @@ export class SharedTreeKernel
 			idCompressor,
 			schema,
 			defaultSchemaPolicy,
-			undefined,
-			changeEnricher,
 		);
 
 		this.checkout = createTreeCheckout(idCompressor, this.mintRevisionTag, revisionTagCodec, {
@@ -328,6 +324,7 @@ export class SharedTreeKernel
 			disposeForksAfterTransaction: options.disposeForksAfterTransaction,
 		});
 
+		this.registerSharedBranchForEditing("main", this.checkout);
 		this.registerCheckout("main", this.checkout);
 
 		this.view = {
@@ -344,35 +341,6 @@ export class SharedTreeKernel
 
 	private registerCheckout(branchId: BranchId, checkout: TreeCheckout): void {
 		this.checkouts.set(branchId, checkout);
-		const enricher = this.getCommitEnricher(branchId);
-		checkout.transaction.events.on("started", () => {
-			if (this.sharedObject.isAttached()) {
-				// It is currently forbidden to attach during a transaction, so transaction state changes can be ignored until after attaching.
-				enricher.startTransaction();
-			}
-		});
-
-		checkout.transaction.events.on("aborting", () => {
-			if (this.sharedObject.isAttached()) {
-				// It is currently forbidden to attach during a transaction, so transaction state changes can be ignored until after attaching.
-				enricher.abortTransaction();
-			}
-		});
-		checkout.transaction.events.on("committing", () => {
-			if (this.sharedObject.isAttached()) {
-				// It is currently forbidden to attach during a transaction, so transaction state changes can be ignored until after attaching.
-				enricher.commitTransaction();
-			}
-		});
-		checkout.events.on("beforeBatch", (event) => {
-			if (
-				event.type === "append" &&
-				this.sharedObject.isAttached() &&
-				checkout.transaction.isInProgress()
-			) {
-				enricher.addTransactionCommits(event.newCommits);
-			}
-		});
 	}
 
 	public exportVerbose(): VerboseTree | undefined {
@@ -440,13 +408,7 @@ export class SharedTreeKernel
 	private checkoutBranch(branchId: BranchId): TreeCheckout {
 		const checkout = this.checkout.branch();
 		checkout.switchBranch(this.getSharedBranch(branchId));
-		const enricher = new SharedTreeReadonlyChangeEnricher(
-			checkout.forest,
-			checkout.storedSchema,
-			checkout.removedRoots,
-		);
-
-		this.registerSharedBranchForEditing(branchId, enricher);
+		this.registerSharedBranchForEditing(branchId, checkout);
 		this.registerCheckout(branchId, checkout);
 		return checkout;
 	}
@@ -587,6 +549,7 @@ export function getBranch<T extends ImplicitFieldSchema | UnsafeUnknownSchema>(
  * Once an entry is defined and used in production, it cannot be changed.
  * This is because the format for SharedTree changes are not explicitly versioned.
  */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- intentional comparison
 export const changeFormatVersionForEditManager = DependentFormatVersion.fromPairs([
 	[
 		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v3),

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -5,6 +5,7 @@
 
 import { fail } from "@fluidframework/core-utils/internal";
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+
 import {
 	type CodecTree,
 	type CodecWriteOptions,

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,
@@ -25,17 +27,28 @@ import {
 	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.
@@ -43,91 +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,
-			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/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");