@fluidframework/tree 2.41.0-338401 → 2.42.0

package/src/simple-tree/prepareForInsertion.ts

@@ -4,10 +4,8 @@
  */
 
 import type {
-	ExclusiveMapTree,
 	SchemaAndPolicy,
 	IForestSubscription,
-	MapTree,
 	UpPath,
 	NodeIndex,
 	FieldKey,
@@ -17,23 +15,23 @@ import type {
 import {
 	type FlexTreeContext,
 	getSchemaAndPolicy,
-	type FlexTreeHydratedContext,
+	type FlexTreeHydratedContextMinimal,
 	FieldKinds,
+	type FlexibleFieldContent,
+	type FlexibleNodeContent,
 } from "../feature-libraries/index.js";
 import {
 	normalizeFieldSchema,
 	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
 } from "./schemaTypes.js";
-import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
+import {
+	type InsertableContent,
+	unhydratedFlexTreeFromInsertable,
+} from "./unhydratedFlexTreeFromInsertable.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
-import {
-	getKernel,
-	type TreeNode,
-	tryUnhydratedFlexTreeNode,
-	unhydratedFlexTreeNodeToTreeNode,
-} from "./core/index.js";
+import { getKernel, type TreeNode, type UnhydratedFlexTreeNode } from "./core/index.js";
 import { debugAssert, oob } from "@fluidframework/core-utils/internal";
 import { inSchemaOrThrow, isFieldInSchema } from "../feature-libraries/index.js";
 import { convertField } from "./toStoredSchema.js";
@@ -50,7 +48,7 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
 	schema: ImplicitFieldSchema,
 	destinationContext: FlexTreeContext,
-): TIn extends undefined ? undefined : ExclusiveMapTree {
+): TIn extends undefined ? undefined : FlexibleNodeContent {
 	return prepareForInsertionContextless(
 		data,
 		schema,
@@ -76,13 +74,9 @@ export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
 	schema: ImplicitAllowedTypes,
 	destinationContext: FlexTreeContext,
-): ExclusiveMapTree[] {
-	const mapTrees: ExclusiveMapTree[] = data.map((item) =>
-		mapTreeFromNodeData(
-			item,
-			schema,
-			destinationContext.isHydrated() ? destinationContext.nodeKeyManager : undefined,
-		),
+): FlexibleFieldContent {
+	const mapTrees: UnhydratedFlexTreeNode[] = data.map((item) =>
+		unhydratedFlexTreeFromInsertable(item, schema),
 	);
 
 	const fieldSchema = convertField(normalizeFieldSchema(schema));
@@ -110,15 +104,15 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
 	data: TIn,
 	schema: ImplicitFieldSchema,
 	schemaAndPolicy: SchemaAndPolicy,
-	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
-): TIn extends undefined ? undefined : ExclusiveMapTree {
-	const mapTree = mapTreeFromNodeData(data, schema, hydratedData?.nodeKeyManager);
+	hydratedData: FlexTreeHydratedContextMinimal | undefined,
+): TIn extends undefined ? undefined : FlexibleNodeContent {
+	const mapTree = unhydratedFlexTreeFromInsertable(data, schema);
 
 	const contentArray = mapTree === undefined ? [] : [mapTree];
 	const fieldSchema = convertField(normalizeFieldSchema(schema));
 	validateAndPrepare(schemaAndPolicy, hydratedData, fieldSchema, contentArray);
 
-	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
+	return mapTree;
 }
 
 /**
@@ -129,16 +123,19 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
  */
 function validateAndPrepare(
 	schemaAndPolicy: SchemaAndPolicy,
-	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
+	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	fieldSchema: TreeFieldStoredSchema,
-	mapTrees: ExclusiveMapTree[],
+	mapTrees: readonly UnhydratedFlexTreeNode[],
 ): void {
 	if (hydratedData !== undefined) {
+		// Run `prepareContentForHydration` before walking the tree in `isFieldInSchema`.
+		// This ensures that when `isFieldInSchema` requests identifiers (or any other contextual defaults),
+		// they were already creating used the more specific context we have access to from `hydratedData`.
+		prepareContentForHydration(mapTrees, hydratedData.checkout.forest, hydratedData);
 		if (schemaAndPolicy.policy.validateSchema === true) {
 			const maybeError = isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy);
 			inSchemaOrThrow(maybeError);
 		}
-		prepareContentForHydration(mapTrees, hydratedData.checkout.forest);
 	}
 }
 
@@ -176,17 +173,21 @@ interface LocatedNodesBatch {
 const placeholderKey: DetachedField & FieldKey = brand("placeholder" as const);
 
 /**
- * Records any proxies in the given content tree and does the necessary bookkeeping to ensure they are synchronized with subsequent reads of the tree.
- * @remarks If the content tree contains any proxies, this function must be called just prior to inserting the content into the tree.
+ * Records any {@link TreeNode}s in the given `content` tree and does the necessary bookkeeping to ensure they are synchronized with subsequent reads of the tree.
+ * Additionally populates any {@link UnhydratedFlexTreeField.pendingDefault}s using the provided `context`.
+ *
+ * @remarks If the content tree contains has any associated {@link TreeNode}s, this function must be called just prior to inserting the content into the tree.
  * Specifically, no other content may be inserted into the tree between the invocation of this function and the insertion of `content`.
  * The insertion of `content` must occur or else this function will cause memory leaks.
+ *
+ * Exported for testing purposes: otherwise should not be used outside this module.
  * @param content - the content subsequence to be inserted, of which might deeply contain {@link TreeNode}s which need to be hydrated.
  * @param forest - the forest the content is being inserted into.
- * See {@link extractFactoryContent} for more details.
  */
-function prepareContentForHydration(
-	content: readonly MapTree[],
+export function prepareContentForHydration(
+	content: readonly UnhydratedFlexTreeNode[],
 	forest: IForestSubscription,
+	context: FlexTreeHydratedContextMinimal,
 ): void {
 	const batches: LocatedNodesBatch[] = [];
 	for (const item of content) {
@@ -199,39 +200,45 @@ function prepareContentForHydration(
 			paths: [],
 		};
 		batches.push(batch);
-		walkMapTree(item, batch.rootPath, (p, node) => {
-			batch.paths.push({ path: p, node });
-		});
+		walkMapTree(
+			item,
+			batch.rootPath,
+			(p, node) => {
+				batch.paths.push({ path: p, node });
+			},
+			context,
+		);
 	}
 
 	scheduleHydration(batches, forest);
 }
 
 function walkMapTree(
-	mapTree: MapTree,
+	root: UnhydratedFlexTreeNode,
 	path: UpPath,
 	onVisitTreeNode: (path: UpPath, treeNode: TreeNode) => void,
+	context: FlexTreeHydratedContextMinimal,
 ): void {
-	if (tryUnhydratedFlexTreeNode(mapTree)?.parentField.parent.parent !== undefined) {
+	if (root.parentField.parent.parent !== undefined) {
 		throw new UsageError(
 			"Attempted to insert a node which is already under a parent. If this is desired, remove the node from its parent before inserting it elsewhere.",
 		);
 	}
 
-	type Next = [path: UpPath, tree: MapTree];
+	type Next = [path: UpPath, tree: UnhydratedFlexTreeNode];
 	const nexts: Next[] = [];
-	for (let next: Next | undefined = [path, mapTree]; next !== undefined; next = nexts.pop()) {
-		const [p, m] = next;
-		const mapTreeNode = tryUnhydratedFlexTreeNode(m);
-		if (mapTreeNode !== undefined) {
-			const treeNode = unhydratedFlexTreeNodeToTreeNode.get(mapTreeNode);
+	for (let next: Next | undefined = [path, root]; next !== undefined; next = nexts.pop()) {
+		const [p, node] = next;
+		if (node !== undefined) {
+			const treeNode = node.treeNode;
 			if (treeNode !== undefined) {
 				onVisitTreeNode(p, treeNode);
 			}
 		}
 
-		for (const [key, field] of m.fields) {
-			for (const [i, child] of field.entries()) {
+		for (const [key, field] of node.allFieldsLazy) {
+			field.fillPendingDefaults(context);
+			for (const [i, child] of field.children.entries()) {
 				nexts.push([
 					{
 						parent: p,

package/src/simple-tree/schemaTypes.ts

@@ -7,7 +7,8 @@ import type { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import type { NodeIdentifierManager } from "../feature-libraries/index.js";
+import type { FieldKey } from "../core/index.js";
+import type { FlexTreeHydratedContextMinimal } from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
 	brand,
@@ -20,6 +21,7 @@ import {
 	type RestrictiveStringRecord,
 	type IsUnion,
 } from "../util/index.js";
+
 import type {
 	Unhydrated,
 	NodeKind,
@@ -28,14 +30,14 @@ import type {
 	TreeNode,
 	TreeNodeSchemaCore,
 	TreeNodeSchemaNonClass,
+	UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import { inPrototypeChain } from "./core/index.js";
-import type { FieldKey } from "../core/index.js";
-import type { InsertableContent } from "./toMapTree.js";
 import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
-import { TreeNodeValid } from "./treeNodeValid.js";
 import type { SimpleFieldSchema, SimpleObjectFieldSchema } from "./simpleSchema.js";
+import type { InsertableContent } from "./unhydratedFlexTreeFromInsertable.js";
+import { TreeNodeValid } from "./treeNodeValid.js";
 
 /**
  * Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.
@@ -295,17 +297,17 @@ export interface FieldProps<TCustomMetadata = unknown> {
 }
 
 /**
- * A {@link FieldProvider} which requires additional context in order to produce its content
+ * A {@link FieldProvider} which prefers to have additional context in order to produce its content.
  */
 export type ContextualFieldProvider = (
-	context: NodeIdentifierManager,
-) => InsertableContent | undefined;
+	context: FlexTreeHydratedContextMinimal | "UseGlobalContext",
+) => UnhydratedFlexTreeNode[];
 /**
- * A {@link FieldProvider} which can produce its content in a vacuum
+ * A {@link FieldProvider} which can produce its content in a vacuum.
  */
-export type ConstantFieldProvider = () => InsertableContent | undefined;
+export type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];
 /**
- * A function which produces content for a field every time that it is called
+ * A function which produces content for a field every time that it is called.
  */
 export type FieldProvider = ContextualFieldProvider | ConstantFieldProvider;
 /**

package/src/simple-tree/simpleSchema.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ValueSchema } from "../core/index.js";
+
 import type { NodeKind } from "./core/index.js";
 import type { FieldKind, FieldSchemaMetadata, NodeSchemaMetadata } from "./schemaTypes.js";
 

package/src/simple-tree/toStoredSchema.ts

@@ -21,16 +21,17 @@ import {
 } from "../core/index.js";
 import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
 import { brand, getOrCreate } from "../util/index.js";
+
 import { NodeKind } from "./core/index.js";
-import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
-import { walkFieldSchema } from "./walkFieldSchema.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
 import type {
 	SimpleFieldSchema,
 	SimpleNodeSchema,
 	SimpleNodeSchemaBase,
 	SimpleTreeSchema,
 } from "./simpleSchema.js";
+import { walkFieldSchema } from "./walkFieldSchema.js";
 
 const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
 
@@ -92,7 +93,13 @@ export function convertField(schema: SimpleFieldSchema): TreeFieldStoredSchema {
 	return { kind, types };
 }
 
-const convertFieldKind = new Map<FieldKind, FlexFieldKind>([
+/**
+ * A map that converts {@link FieldKind} to {@link FlexFieldKind}.
+ */
+export const convertFieldKind: ReadonlyMap<FieldKind, FlexFieldKind> = new Map<
+	FieldKind,
+	FlexFieldKind
+>([
 	[FieldKind.Optional, FieldKinds.optional],
 	[FieldKind.Required, FieldKinds.required],
 	[FieldKind.Identifier, FieldKinds.identifier],

package/src/simple-tree/treeNodeValid.ts

@@ -4,6 +4,9 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
 
 import {
 	type TreeNodeSchema,
@@ -18,9 +21,6 @@ import {
 	type Context,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
-
 import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 import { markEager } from "./flexList.js";