@fluidframework/tree 2.81.0-374083 → 2.81.1

package/src/index.ts

@@ -366,4 +366,4 @@ export { FluidSerializableAsTree } from "./serializableDomainSchema.js";
 export { TableSchema, type System_TableSchema } from "./tableSchema.js";
 export { asAlpha, asBeta } from "./api.js";
 
-export { TextAsTree } from "./text/index.js";
+export { TextAsTree, FormattedTextAsTree } from "./text/index.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.81.0-374083";
+export const pkgVersion = "2.81.1";

package/src/shared-tree/independentView.ts

@@ -30,6 +30,7 @@ import {
 	TreeCompressionStrategy,
 	defaultIncrementalEncodingPolicy,
 } from "../feature-libraries/index.js";
+import { combineChunks } from "../feature-libraries/index.js";
 // eslint-disable-next-line import-x/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/formatV1.js";
 import type {
@@ -49,6 +50,9 @@ import {
 	Breakable,
 	oneFromIterable,
 } from "../util/index.js";
+
+import { initialize, initializerFromChunk } from "./schematizeTree.js";
+import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import {
 	buildConfiguredForest,
 	defaultSharedTreeOptions,
@@ -56,9 +60,6 @@ import {
 	type ForestOptions,
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
-import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import { initialize, initializerFromChunk } from "./schematizeTree.js";
-import { combineChunks } from "../feature-libraries/index.js";
 
 /**
  * Create an uninitialized {@link TreeView} that is not tied to any {@link ITree} instance.

package/src/shared-tree/index.ts

@@ -41,10 +41,9 @@ export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 export { initialize, initializerFromChunk } from "./schematizeTree.js";
 
 export type {
-	IIdBasedSharedTreeEditor,
-	ILocationBasedSharedTreeEditor,
+	ISharedTreeEditor,
 	ISchemaEditor,
-	IdBasedSharedTreeEditBuilder,
+	SharedTreeEditBuilder,
 } from "./sharedTreeEditBuilder.js";
 
 export { Tree } from "./tree.js";

package/src/shared-tree/schematizeTree.ts

@@ -5,19 +5,12 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	type ChangeAtomId,
-	type TreeStoredSchema,
-	rootFieldKey,
-	schemaDataIsEmpty,
-} from "../core/index.js";
+import { type TreeStoredSchema, rootFieldKey, schemaDataIsEmpty } from "../core/index.js";
 import {
 	FieldKinds,
 	allowsRepoSuperset,
 	defaultSchemaPolicy,
-	type DetachedRootIds,
-	type ILocationBasedDataEditor,
-	type DataEditor,
+	type IDefaultEditBuilder,
 	type TreeChunk,
 } from "../feature-libraries/index.js";
 
@@ -44,11 +37,11 @@ export function canInitialize(checkout: ITreeCheckout): boolean {
  * @privateRemarks
  * This takes in a checkout using a subset of the checkout interface to enable easier unit testing.
  */
-export function initialize<T>(
+export function initialize(
 	checkout: Pick<ITreeCheckout, "storedSchema" | "updateSchema">,
 	newSchema: TreeStoredSchema,
-	setInitialTree: () => T,
-): T {
+	setInitialTree: () => void,
+): void {
 	assert(
 		schemaDataIsEmpty(checkout.storedSchema),
 		0x743 /* cannot initialize after a schema is set */,
@@ -85,15 +78,13 @@ export function initialize<T>(
 	);
 
 	checkout.updateSchema(intermediateSchema);
-	const result = setInitialTree();
+	setInitialTree();
 
 	// If intermediate schema is not final desired schema, update to the final schema:
 	if (intermediateSchema !== newSchema) {
 		// This makes the root more strict, so set allowNonSupersetSchema to true.
 		checkout.updateSchema(newSchema, true);
 	}
-
-	return result;
 }
 
 /**
@@ -108,9 +99,7 @@ export function initialize<T>(
  */
 export function initializerFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor:
-			| ILocationBasedDataEditor
-			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
+		readonly editor: IDefaultEditBuilder;
 	},
 	contentFactory: () => TreeChunk,
 ): () => void {
@@ -119,9 +108,7 @@ export function initializerFromChunk(
 
 function initializeFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor:
-			| ILocationBasedDataEditor
-			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
+		readonly editor: IDefaultEditBuilder;
 	},
 	contentChunk: TreeChunk,
 ): void {

package/src/shared-tree/schematizingTreeView.ts

@@ -16,8 +16,10 @@ import { anchorSlot, rootFieldKey } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
+	cursorForMapTreeField,
 	TreeStatus,
 	Context,
+	combineChunks,
 	type FlexTreeOptionalField,
 	type FlexTreeUnknownUnboxed,
 	FieldKinds,
@@ -65,12 +67,11 @@ import {
 	type Breakable,
 	breakingClass,
 	disposeSymbol,
-	hasSingle,
 	type JsonCompatibleReadOnly,
 	type WithBreakable,
 } from "../util/index.js";
 
-import { canInitialize, initialize } from "./schematizeTree.js";
+import { canInitialize, initialize, initializerFromChunk } from "./schematizeTree.js";
 import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
 
 /**
@@ -123,6 +124,11 @@ export class SchematizingSimpleTreeView<
 	 */
 	private midUpgrade = false;
 
+	/**
+	 * Hydration work deferred until Context has been created.
+	 */
+	private pendingHydration?: () => void;
+
 	private readonly rootFieldSchema: FieldSchema;
 	public readonly breaker: Breakable;
 
@@ -184,54 +190,57 @@ export class SchematizingSimpleTreeView<
 
 		this.runSchemaEdit(() => {
 			const schema = toInitialSchema(this.config.schema);
-			this.checkout.transaction.start();
-			initialize(this.checkout, schema, () => {
-				const preparedContent = prepareForInsertionContextless(
-					content as InsertableContent | undefined,
-					this.rootFieldSchema,
-					{
-						schema,
-						policy: defaultSchemaPolicy,
-					},
-					this,
-					schema.rootFieldSchema,
-				);
-
-				if (preparedContent.rootsLocations.length === 0) {
-					// If there's no content to attach, no work is needed
-					return undefined;
-				}
+			// This has to be the contextless version, since when "initialize" is called (right after this),
+			// it will do a schema change which would dispose of the current context (see inside `update`).
+			// Thus using the current context (if any) would hydrate nodes then
+			// immediately dispose them instead of having them actually be useable after initialize.
+			// For this to work,
+			// the hydration must be deferred until after the content is inserted into the tree and the final schema change is done (for required roots),
+			// but before any user event could could run.
+			const mapTree = prepareForInsertionContextless(
+				content as InsertableContent | undefined,
+				this.rootFieldSchema,
+				{
+					schema,
+					policy: defaultSchemaPolicy,
+				},
+				this,
+				schema.rootFieldSchema,
+				(batches, doHydration) => {
+					assert(
+						this.pendingHydration === undefined,
+						0xc74 /* pendingHydration already set */,
+					);
+					this.pendingHydration = () => {
+						assert(
+							batches.length <= 1,
+							0xc75 /* initialize should at most one hydration batch */,
+						);
+						for (const batch of batches) {
+							doHydration(batch, {
+								parent: undefined,
+								parentField: rootFieldKey,
+								parentIndex: 0,
+							});
+						}
+					};
+				},
+			);
 
-				const field = { field: rootFieldKey, parent: undefined };
-				assert(
-					this.checkout.storedSchema.rootFieldSchema.kind === FieldKinds.optional.identifier,
-					"initializerFromChunk only supports optional roots",
-				);
+			this.checkout.transaction.start();
 
-				assert(
-					hasSingle(preparedContent.rootsLocations) &&
-						preparedContent.rootsLocations[0].count === 1,
-					"Expected one root",
-				);
-				const fieldEditor = this.checkout.editor.optionalField(field);
-				fieldEditor.attach(preparedContent.rootsLocations[0].field, true);
-
-				return preparedContent;
-			})?.finalize([...this.getFlexTreeContext().root]);
-
-			// TODO:CM
-			// initialize(
-			// 	this.checkout,
-			// 	schema,
-			// 	initializerFromChunk(this.checkout, () => {
-			// 		// This must be done after initial schema is set!
-			// 		return combineChunks(
-			// 			this.checkout.forest.chunkField(
-			// 				cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
-			// 			),
-			// 		);
-			// 	}),
-			// );
+			initialize(
+				this.checkout,
+				schema,
+				initializerFromChunk(this.checkout, () => {
+					// This must be done after initial schema is set!
+					return combineChunks(
+						this.checkout.forest.chunkField(
+							cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
+						),
+					);
+				}),
+			);
 			this.checkout.transaction.commit();
 		});
 	}
@@ -285,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 = (
@@ -303,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 };
@@ -386,7 +395,9 @@ export class SchematizingSimpleTreeView<
 
 				// Track what the root was before to be able to detect changes.
 				// This uses the flex tree root to avoid demanding the simple-tree TreeNode when it might not be hydrated yet.
-				let lastRoot: FlexTreeUnknownUnboxed | undefined = this.flexRoot.content;
+				let lastRoot: FlexTreeUnknownUnboxed | undefined = (
+					this.flexTreeContext.root as FlexTreeOptionalField
+				).content;
 
 				this.flexTreeViewUnregisterCallbacks.add(
 					this.checkout.events.on("afterBatch", () => {
@@ -410,6 +421,10 @@ export class SchematizingSimpleTreeView<
 		);
 
 		if (!this.midUpgrade) {
+			assert(
+				this.pendingHydration === undefined,
+				0xc76 /* no nodes should be pending hydration when triggering events that could access nodes */,
+			);
 			this.events.emit("schemaChanged");
 			this.events.emit("rootChanged");
 		}
@@ -422,6 +437,9 @@ export class SchematizingSimpleTreeView<
 		} finally {
 			this.midUpgrade = false;
 		}
+		// Ensure hydration is flushed before events run which could access nodes.
+		this.pendingHydration?.();
+		this.pendingHydration = undefined;
 		this.events.emit("schemaChanged");
 		this.events.emit("rootChanged");
 	}
@@ -537,7 +555,7 @@ export function getCheckout(context: TreeBranch): TreeCheckout {
  * Adds constraints to a `checkout`'s pending transaction.
  *
  * @param checkout - The checkout's who's transaction will have the constraints added to it.
- * @param constraintsOnRevert - If true, use {@link IIdBasedSharedTreeEditor.addNodeExistsConstraintOnRevert}.
+ * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
  * @param constraints - The constraints to add to the transaction.
  *
  * @see {@link RunTransactionParams.preconditions}.

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 { IdBasedSharedTreeEditBuilder } 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.
@@ -181,7 +180,7 @@ export type SharedTreeKernelView = Omit<ITreePrivate, keyof (IChannelView & IFlu
  */
 @breakingClass
 export class SharedTreeKernel
-	extends SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>
+	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
 	implements SharedKernel
 {
 	public readonly checkout: TreeCheckout;
@@ -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;
 	}
@@ -471,7 +433,7 @@ export class SharedTreeKernel
 
 	public override applyStashedOp(
 		...args: Parameters<
-			SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
+			SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
 		>
 	): void {
 		for (const checkout of this.checkouts.values()) {
@@ -605,10 +567,6 @@ export const changeFormatVersionForEditManager = DependentFormatVersion.fromPair
 		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v6),
 		brand<SharedTreeChangeFormatVersion>(5),
 	],
-	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.vDetachedRoots),
-		brand<SharedTreeChangeFormatVersion>(101),
-	],
 ]);
 
 /**
@@ -634,10 +592,6 @@ export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
 		brand<MessageFormatVersion>(MessageFormatVersion.v6),
 		brand<SharedTreeChangeFormatVersion>(5),
 	],
-	[
-		brand<MessageFormatVersion>(MessageFormatVersion.vDetachedRoots),
-		brand<SharedTreeChangeFormatVersion>(101),
-	],
 ]);
 
 function getCodecTreeForEditManagerFormat(clientVersion: MinimumVersionForCollab): CodecTree {
@@ -693,12 +647,6 @@ export interface SharedTreeOptions
 	 * Defaults to false.
 	 */
 	readonly enableSharedBranches?: boolean;
-	/**
-	 * Experimental feature flag to enable the ability to edit detached roots.
-	 * This feature is not yet complete and should not be used in production.
-	 * Defaults to false.
-	 */
-	readonly enableDetachedRootEditing?: boolean;
 	/**
 	 * Returns whether a node / field should be incrementally encoded.
 	 * @remarks
@@ -841,8 +789,6 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	enableSharedBranches: false,
 	writeVersionOverrides: new Map(),
 	allowPossiblyIncompatibleWriteVersionOverrides: false,
-	enableDetachedRootEditing: false,
-	canMakeDetachedRootEdits: false,
 };
 
 /**

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,
@@ -74,10 +75,7 @@ interface ChangeFormatDependencies {
 	readonly schemaChange: SchemaFormatVersion;
 }
 
-export type SharedTreeChangeFormatVersion = Brand<
-	3 | 4 | 5 | 101,
-	"SharedTreeChangeFormatVersion"
->;
+export type SharedTreeChangeFormatVersion = Brand<3 | 4 | 5, "SharedTreeChangeFormatVersion">;
 
 /**
  * Defines for each SharedTree change format the corresponding dependent formats to use.
@@ -92,7 +90,6 @@ export const dependenciesForChangeFormat: Map<
 	[brand(3), { modularChange: brand(3), schemaChange: SchemaFormatVersion.v1 }],
 	[brand(4), { modularChange: brand(4), schemaChange: SchemaFormatVersion.v1 }],
 	[brand(5), { modularChange: brand(5), schemaChange: SchemaFormatVersion.v1 }],
-	[brand(101), { modularChange: brand(101), schemaChange: brand(SchemaFormatVersion.v1) }],
 ]);
 
 export function getCodecTreeForChangeFormat(