@fluidframework/tree 2.3.1 → 2.4.0-297027

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,
@@ -123,6 +129,10 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		);
 	}
 
+	public get schema(): TRootSchema {
+		return this.config.schema;
+	}
+
 	public initialize(content: InsertableTreeFieldFromImplicitField<TRootSchema>): void {
 		this.ensureUndisposed();
 
@@ -147,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),
 			});
 		});
@@ -174,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,
 				},
 			);
@@ -267,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();
@@ -279,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();
@@ -309,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 {
@@ -325,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> {
@@ -359,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 */);
@@ -373,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.
  *