@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -11,7 +11,7 @@ import {
 	type FlexibleNodeContent,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
-	type OptionalFieldEditor,
+	type OptionalFieldEditBuilder,
 } from "../../../feature-libraries/index.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
 import { createFieldSchema, FieldKind } from "../../fieldSchema.js";
@@ -177,14 +177,14 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		return getInnerNode(this);
 	}
 
-	private editor(key: string): OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode> {
+	private editor(key: string): OptionalFieldEditBuilder<FlexibleNodeContent> {
 		const field = this.innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
 		return field.editor;
 	}
 
 	public delete(key: string): void {
 		const field = this.innerNode.getBoxed(brand(key));
-		this.editor(key).clear(field.length === 0);
+		this.editor(key).set(undefined, field.length === 0);
 	}
 	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
 		const node = this.innerNode;
@@ -227,7 +227,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 
 		const field = node.getBoxed(brand(key));
 
-		this.editor(key).attach(mapTree, field.length === 0);
+		this.editor(key).set(mapTree, field.length === 0);
 		return this;
 	}
 	public get size(): number {

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -81,7 +81,7 @@ import {
 import type { SimpleObjectFieldSchema } from "../../simpleSchema.js";
 import {
 	unhydratedFlexTreeFromInsertable,
-	flexTreeFromInsertableNode,
+	unhydratedFlexTreeFromInsertableNode,
 	type FactoryContent,
 	type FactoryContentObject,
 	type InsertableContent,
@@ -353,31 +353,30 @@ export function setField(
 	value: InsertableContent | undefined,
 	destinationSchema: TreeFieldStoredSchema,
 ): void {
-	field.context.runInTransaction(() => {
-		const mapTree = prepareForInsertion(
-			value,
-			simpleFieldSchema,
-			field.context,
-			destinationSchema,
-		);
+	const mapTree = prepareForInsertion(
+		value,
+		simpleFieldSchema,
+		field.context,
+		destinationSchema,
+	);
 
-		switch (field.schema) {
-			case FieldKinds.required.identifier: {
-				assert(mapTree !== undefined, 0xa04 /* Cannot set a required field to undefined */);
-				const typedField = field as FlexTreeRequiredField;
-				typedField.editor.attach(mapTree);
-				break;
-			}
-			case FieldKinds.optional.identifier: {
-				const typedField = field as FlexTreeOptionalField;
-				typedField.editor.attach(mapTree, typedField.length === 0);
-				break;
-			}
+	switch (field.schema) {
+		case FieldKinds.required.identifier: {
+			assert(mapTree !== undefined, 0xa04 /* Cannot set a required field to undefined */);
+			const typedField = field as FlexTreeRequiredField;
+			typedField.editor.set(mapTree);
+			break;
+		}
+		case FieldKinds.optional.identifier: {
+			const typedField = field as FlexTreeOptionalField;
+			typedField.editor.set(mapTree, typedField.length === 0);
+			break;
+		}
 
-			default:
-				fail(0xade /* invalid FieldKind */);
+		default: {
+			fail(0xade /* invalid FieldKind */);
 		}
-	});
+	}
 }
 
 /**
@@ -663,7 +662,7 @@ function objectToFlexContent(
 	for (const [key, fieldInfo] of schema.flexKeyMap) {
 		const value = getFieldProperty(data, key);
 
-		let children: FlexTreeNode[] | ContextualFieldProvider;
+		let children: UnhydratedFlexTreeNode[] | ContextualFieldProvider;
 		if (value === undefined) {
 			const defaultProvider =
 				fieldInfo.schema.props?.defaultProvider ??
@@ -671,7 +670,9 @@ function objectToFlexContent(
 			const fieldProvider = extractFieldProvider(defaultProvider);
 			children = isConstant(fieldProvider) ? fieldProvider() : fieldProvider;
 		} else {
-			children = [flexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet)];
+			children = [
+				unhydratedFlexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet),
+			];
 		}
 
 		const kind =
@@ -709,10 +710,8 @@ function shallowCompatibilityTest(
 
 	// If the schema has a required key which is not present in the input object, reject it.
 	for (const [fieldKey, fieldSchema] of schema.fields) {
-		if (fieldSchema.requiresValue) {
-			if (getFieldProperty(data, fieldKey) === undefined) {
-				return CompatibilityLevel.None;
-			}
+		if (fieldSchema.requiresValue && getFieldProperty(data, fieldKey) === undefined) {
+			return CompatibilityLevel.None;
 		}
 	}
 

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -99,9 +99,8 @@ function createRecordNodeProxy(
 						}
 						break;
 					}
-					default: {
-						// No-op
-					}
+					default:
+					// No-op
 				}
 			}
 
@@ -128,16 +127,15 @@ function createRecordNodeProxy(
 				innerSchema instanceof MapNodeStoredSchema,
 				0xc1a /* Expected MapNodeStoredSchema */,
 			);
-			field.context.runInTransaction(() => {
-				const mapTree = prepareForInsertion(
-					value,
-					createFieldSchema(FieldKind.Optional, kernel.schema.info as ImplicitAllowedTypes),
-					innerNode.context,
-					innerSchema.mapFields,
-				);
-
-				field.editor.attach(mapTree, field.length === 0);
-			});
+
+			const mapTree = prepareForInsertion(
+				value,
+				createFieldSchema(FieldKind.Optional, kernel.schema.info as ImplicitAllowedTypes),
+				innerNode.context,
+				innerSchema.mapFields,
+			);
+
+			field.editor.set(mapTree, field.length === 0);
 			return true;
 		},
 		has: (target, key): boolean => {