@fluidframework/tree 2.4.0-294316 → 2.4.0-297027

package/src/shared-tree/index.ts

@@ -8,6 +8,7 @@ export {
 	SharedTreeFactory,
 	type SharedTreeOptions,
 	SharedTree,
+	getBranch,
 	ForestType,
 	type SharedTreeContentSnapshot,
 	type SharedTreeFormatOptions,
@@ -22,16 +23,11 @@ export {
 	type CheckoutEvents,
 	type ITransaction,
 	type ITreeCheckoutFork,
+	type TreeBranch,
+	type TreeBranchFork,
 } from "./treeCheckout.js";
 
-export {
-	type SchematizeConfiguration,
-	type TreeContent,
-	type TreeStoredContent,
-	type InitializeAndSchematizeConfiguration,
-	type SchemaConfiguration,
-	buildTreeConfiguration,
-} from "./schematizeTree.js";
+export { type TreeStoredContent } from "./schematizeTree.js";
 
 export { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 

package/src/shared-tree/schematizeTree.ts

@@ -16,9 +16,6 @@ import {
 } from "../core/index.js";
 import {
 	FieldKinds,
-	type FlexFieldSchema,
-	type FlexTreeSchema,
-	type ViewSchema,
 	allowsRepoSuperset,
 	cursorForMapTreeField,
 	defaultSchemaPolicy,
@@ -27,6 +24,7 @@ import {
 import { fail, isReadonlyArray } from "../util/index.js";
 
 import type { ITreeCheckout } from "./treeCheckout.js";
+import type { ViewSchema } from "../simple-tree/index.js";
 
 /**
  * Modify `storedSchema` and invoke `setInitialTree` when it's time to set the tree content.
@@ -246,7 +244,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(viewSchema.storedSchema);
+			checkout.updateSchema(viewSchema.schema);
 			return true;
 		}
 		case UpdateType.Initialize: {
@@ -265,28 +263,6 @@ export function ensureSchema(
 	}
 }
 
-/**
- * View Schema for a `SharedTree`.
- */
-export interface SchemaConfiguration<TRoot extends FlexFieldSchema = FlexFieldSchema> {
-	/**
-	 * The schema which the application wants to view the tree with.
-	 */
-	readonly schema: FlexTreeSchema<TRoot>;
-}
-
-/**
- * Content that can populate a `SharedTree`.
- */
-export interface TreeContent<TRoot extends FlexFieldSchema = FlexFieldSchema>
-	extends SchemaConfiguration<TRoot> {
-	/**
-	 * Default tree content to initialize the tree with iff the tree is uninitialized
-	 * (meaning it does not even have any schema set at all).
-	 */
-	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
-}
-
 /**
  * Content that can populate a `SharedTree`.
  */
@@ -299,33 +275,3 @@ export interface TreeStoredContent {
 	 */
 	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
 }
-
-/**
- * Options used to schematize a `SharedTree`.
- */
-export interface SchematizeConfiguration<TRoot extends FlexFieldSchema = FlexFieldSchema>
-	extends SchemaConfiguration<TRoot> {
-	/**
-	 * Controls if and how schema from existing documents can be updated to accommodate the view schema.
-	 */
-	readonly allowedSchemaModifications: AllowedUpdateType;
-}
-
-/**
- * Options used to initialize (if needed) and schematize a `SharedTree`.
- */
-export interface InitializeAndSchematizeConfiguration<
-	TRoot extends FlexFieldSchema = FlexFieldSchema,
-> extends TreeContent<TRoot>,
-		SchematizeConfiguration<TRoot> {}
-
-/**
- * Options used to initialize (if needed) and schematize a `SharedTree`.
- * @remarks
- * Using this builder improves type safety and error quality over just constructing the configuration as a object.
- */
-export function buildTreeConfiguration<T extends FlexFieldSchema>(
-	config: InitializeAndSchematizeConfiguration<T>,
-): InitializeAndSchematizeConfiguration<T> {
-	return config;
-}

package/src/shared-tree/schematizingTreeView.ts

@@ -6,7 +6,12 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { AllowedUpdateType, anchorSlot, Compatibility } from "../core/index.js";
+import {
+	AllowedUpdateType,
+	anchorSlot,
+	Compatibility,
+	type SchemaPolicy,
+} from "../core/index.js";
 import {
 	type HasListeners,
 	type IEmitter,
@@ -15,12 +20,10 @@ import {
 } from "../events/index.js";
 import {
 	type NodeKeyManager,
-	ViewSchema,
 	defaultSchemaPolicy,
 	ContextSlot,
 	cursorForMapTreeNode,
-	type FlexTreeSchema,
-	intoStoredSchema,
+	type FullSchemaPolicy,
 } from "../feature-libraries/index.js";
 import {
 	type FieldSchema,
@@ -31,19 +34,21 @@ import {
 	type TreeView,
 	type TreeViewEvents,
 	getTreeNodeForField,
-	toFlexSchema,
 	setField,
 	normalizeFieldSchema,
+	ViewSchema,
 	type InsertableContent,
 	type TreeViewConfiguration,
 	mapTreeFromNodeData,
 	prepareContentForHydration,
+	toStoredSchema,
 } from "../simple-tree/index.js";
 import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../util/index.js";
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
-import type { ITreeCheckout } from "./treeCheckout.js";
+import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
 import { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
+import { HydratedContext, SimpleContextSlot } from "../simple-tree/index.js";
 /**
  * Creating multiple tree views from the same checkout is not supported. This slot is used to detect if one already
  * exists and error if creating a second.
@@ -68,7 +73,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	 * Undefined iff uninitialized or disposed.
 	 */
 	private currentCompatibility: SchemaCompatibilityStatus | undefined;
-	private readonly flexSchema: FlexTreeSchema;
+	private readonly schemaPolicy: SchemaPolicy;
 	public readonly events: Listenable<TreeViewEvents> &
 		IEmitter<TreeViewEvents> &
 		HasListeners<TreeViewEvents> = createEmitter();
@@ -89,10 +94,11 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	private readonly rootFieldSchema: FieldSchema;
 
 	public constructor(
-		public readonly checkout: ITreeCheckout,
+		public readonly checkout: TreeCheckout,
 		public readonly config: TreeViewConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
 		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
+		private readonly onDispose?: () => void,
 	) {
 		if (checkout.forest.anchors.slots.has(ViewSlot)) {
 			throw new UsageError("Cannot create a second tree view from the same checkout");
@@ -104,9 +110,9 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 			validateSchema: config.enableSchemaValidation,
 		};
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
-		this.flexSchema = toFlexSchema(config.schema);
+		this.schemaPolicy = defaultSchemaPolicy;
 
-		this.viewSchema = new ViewSchema(policy, {}, intoStoredSchema(this.flexSchema));
+		this.viewSchema = new ViewSchema(policy, {}, toStoredSchema(this.rootFieldSchema));
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -151,7 +157,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 			prepareContentForHydration(mapTree, this.checkout.forest);
 			initialize(this.checkout, {
-				schema: this.viewSchema.storedSchema,
+				schema: this.viewSchema.schema,
 				initialTree: mapTree === undefined ? undefined : cursorForMapTreeNode(mapTree),
 			});
 		});
@@ -178,7 +184,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				AllowedUpdateType.SchemaCompatible,
 				this.checkout,
 				{
-					schema: this.viewSchema.storedSchema,
+					schema: this.viewSchema.schema,
 					initialTree: undefined,
 				},
 			);
@@ -271,9 +277,17 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				this.viewSchema,
 				onViewDispose,
 				this.nodeKeyManager,
-				this.flexSchema,
+				this.schemaPolicy,
 			);
 			this.view = view;
+			assert(
+				!this.checkout.forest.anchors.slots.has(SimpleContextSlot),
+				"extra simple tree context",
+			);
+			this.checkout.forest.anchors.slots.set(
+				SimpleContextSlot,
+				new HydratedContext(this.rootFieldSchema.allowedTypeSet, view.context),
+			);
 
 			const unregister = this.checkout.storedSchema.on("afterSchemaChange", () => {
 				unregister();
@@ -283,6 +297,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 			this.unregisterCallbacks.add(unregister);
 		} else {
 			this.view = undefined;
+			this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
 
 			const unregister = this.checkout.storedSchema.on("afterSchemaChange", () => {
 				unregister();
@@ -313,8 +328,10 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		if (this.view !== undefined) {
 			this.view[disposeSymbol]();
 			this.view = undefined;
+			this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
 			this.unregisterCallbacks.forEach((unregister) => unregister());
 		}
+		this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
 	}
 
 	public get compatibility(): SchemaCompatibilityStatus {
@@ -329,6 +346,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		this.disposeView();
 		this.checkout.forest.anchors.slots.delete(ViewSlot);
 		this.currentCompatibility = undefined;
+		this.onDispose?.();
 	}
 
 	public get root(): TreeFieldFromImplicitField<TRootSchema> {
@@ -363,7 +381,7 @@ export function requireSchema(
 	viewSchema: ViewSchema,
 	onDispose: () => void,
 	nodeKeyManager: NodeKeyManager,
-	flexTreeSchema: FlexTreeSchema,
+	schemaPolicy: FullSchemaPolicy,
 ): CheckoutFlexTreeView {
 	const slots = checkout.forest.anchors.slots;
 	assert(!slots.has(ContextSlot), 0x8c2 /* Cannot create second view from checkout */);
@@ -377,7 +395,8 @@ export function requireSchema(
 		);
 	}
 
-	const view = new CheckoutFlexTreeView(checkout, flexTreeSchema, nodeKeyManager, onDispose);
+	const view = new CheckoutFlexTreeView(checkout, schemaPolicy, nodeKeyManager, onDispose);
 	assert(slots.has(ContextSlot), 0x90d /* Context should be tracked in slot */);
+
 	return view;
 }

package/src/shared-tree/sharedTree.ts

@@ -36,7 +36,6 @@ import {
 	TreeCompressionStrategy,
 	buildChunkedForest,
 	buildForest,
-	createNodeKeyManager,
 	defaultSchemaPolicy,
 	jsonableTreeFromFieldCursor,
 	makeFieldBatchCodec,
@@ -51,6 +50,7 @@ import {
 import type {
 	ITree,
 	ImplicitFieldSchema,
+	TreeView,
 	TreeViewConfiguration,
 } from "../simple-tree/index.js";
 
@@ -59,7 +59,12 @@ import { SharedTreeReadonlyChangeEnricher } from "./sharedTreeChangeEnricher.js"
 import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
-import { type CheckoutEvents, type TreeCheckout, createTreeCheckout } from "./treeCheckout.js";
+import {
+	type CheckoutEvents,
+	type TreeCheckout,
+	type TreeBranch,
+	createTreeCheckout,
+} from "./treeCheckout.js";
 import { breakingClass, throwIfBroken } from "../util/index.js";
 
 /**
@@ -279,6 +284,7 @@ export class SharedTree
 				removedRoots,
 				chunkCompressionStrategy: options.treeEncodeType,
 				logger: this.logger,
+				breaker: this.breaker,
 			},
 		);
 	}
@@ -301,12 +307,7 @@ export class SharedTree
 	public viewWith<TRoot extends ImplicitFieldSchema>(
 		config: TreeViewConfiguration<TRoot>,
 	): SchematizingSimpleTreeView<TRoot> {
-		return new SchematizingSimpleTreeView(
-			this.checkout,
-			config,
-			createNodeKeyManager(this.runtime.idCompressor),
-			this.breaker,
-		);
+		return this.checkout.viewWith(config);
 	}
 
 	protected override async loadCore(services: IChannelStorageService): Promise<void> {
@@ -316,6 +317,33 @@ export class SharedTree
 	}
 }
 
+/**
+ * Get a {@link TreeBranch} from a {@link ITree}.
+ * @remarks The branch can be used for "version control"-style coordination of edits on the tree.
+ * @privateRemarks This function will be removed if/when the branching API becomes public,
+ * but it (or something like it) is necessary in the meantime to prevent the alpha types from being exposed as public.
+ * @alpha
+ */
+export function getBranch(tree: ITree): TreeBranch;
+/**
+ * Get a {@link TreeBranch} from a {@link TreeView}.
+ * @remarks The branch can be used for "version control"-style coordination of edits on the tree.
+ * Branches are currently an unstable "alpha" API and are subject to change in the future.
+ * @privateRemarks This function will be removed if/when the branching API becomes public,
+ * but it (or something like it) is necessary in the meantime to prevent the alpha types from being exposed as public.
+ * @alpha
+ */
+export function getBranch(view: TreeView<ImplicitFieldSchema>): TreeBranch;
+export function getBranch(treeOrView: ITree | TreeView<ImplicitFieldSchema>): TreeBranch {
+	assert(
+		treeOrView instanceof SharedTree || treeOrView instanceof SchematizingSimpleTreeView,
+		"Unsupported implementation",
+	);
+	const checkout: TreeCheckout = treeOrView.checkout;
+	// This cast is safe so long as TreeCheckout supports all the operations on the branch interface.
+	return checkout as unknown as TreeBranch;
+}
+
 /**
  * Format versions supported by SharedTree.
  *