@fluidframework/tree 2.90.0-378676 → 2.91.0

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

@@ -70,6 +70,7 @@ import {
 	type ContextualFieldProvider,
 	extractFieldProvider,
 	isConstant,
+	type DefaultProvider,
 } from "../../fieldSchema.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
@@ -77,7 +78,7 @@ import type { SimpleObjectFieldSchema } from "../../simpleSchema.js";
 import { convertFieldKind } from "../../toStoredSchema.js";
 import {
 	unhydratedFlexTreeFromInsertable,
-	flexTreeFromInsertableNode,
+	unhydratedFlexTreeFromInsertableNode,
 	type FactoryContent,
 	type FactoryContentObject,
 	type InsertableContent,
@@ -99,8 +100,7 @@ import type {
  */
 export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> =
 	RestrictiveStringRecord<ImplicitFieldSchema> extends T
-		? // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-			{}
+		? {}
 		: {
 				-readonly [Property in keyof T]: Property extends string
 					? TreeFieldFromImplicitField<T[Property]>
@@ -149,8 +149,11 @@ export type TreeObjectNode<
  * @remarks Yields `false` when unknown.
  *
  * @privateRemarks
- * TODO: Account for field schemas with default value providers.
- * For now, this only captures field kinds that we know always have defaults - optional fields and identifier fields.
+ * This checks for:
+ * 1. Optional fields (which have an implicit undefined default)
+ * 2. Identifier fields (which have auto-generated defaults)
+ *
+ * Note that this cannot tell if required fields have defaults. Use `FieldHasDefaultAlpha` for alpha schemas if you need to check for required field defaults.
  *
  * @system @public
  */
@@ -160,6 +163,33 @@ export type FieldHasDefault<T extends ImplicitFieldSchema> = [T] extends [
 	? true
 	: false;
 
+/**
+ * Type utility for determining if an implicit field schema is known to have a default value.
+ * Supports alpha field schemas with explicit default providers.
+ *
+ * @remarks Yields `false` when unknown.
+ *
+ * @privateRemarks
+ * This checks for:
+ * 1. Fields with explicit default providers (computed from the props type)
+ * 2. Optional fields (which have an implicit undefined default)
+ * 3. Identifier fields (which have auto-generated defaults)
+ *
+ * @system @alpha
+ */
+export type FieldHasDefaultAlpha<T extends ImplicitFieldSchema> =
+	// Extract Kind and TProps from FieldSchemaAlpha and compute whether it has a default
+	[T] extends [FieldSchemaAlpha<infer Kind, infer _Types, infer _Meta, infer TProps>]
+		? // Optional and Identifier kinds always have defaults
+			Kind extends FieldKind.Optional | FieldKind.Identifier
+			? true
+			: // Check if props has defaultProvider
+				TProps extends { defaultProvider: DefaultProvider }
+				? true
+				: false
+		: // Fallback to base FieldHasDefault for non-Alpha schemas
+			FieldHasDefault<T>;
+
 /**
  * Helper used to produce types for:
  *
@@ -209,6 +239,35 @@ export type InsertableObjectFromSchemaRecord<
 				}
 			>;
 
+/**
+ * Alpha version of InsertableObjectFromSchemaRecord that supports field defaults.
+ *
+ * @system @alpha
+ */
+export type InsertableObjectFromSchemaRecordAlpha<
+	T extends RestrictiveStringRecord<ImplicitFieldSchema>,
+> =
+	RestrictiveStringRecord<ImplicitFieldSchema> extends T
+		? { arbitraryKey: "arbitraryValue" } extends T
+			? // {} case
+				Record<string, never>
+			: // RestrictiveStringRecord<ImplicitFieldSchema> case
+				never
+		: FlattenKeys<
+				{
+					readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<
+						T[Property & string]
+					>;
+				} & {
+					// Field does not have a known default, make it required:
+					readonly [Property in keyof T as FieldHasDefaultAlpha<
+						T[Property & string]
+					> extends false
+						? Property
+						: never]: InsertableTreeFieldFromImplicitField<T[Property & string]>;
+				}
+			>;
+
 /**
  * Maps from simple field keys ("property" keys) to information about the field.
  *
@@ -354,32 +413,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 */);
 		}
-	});
+	}
 }
 
 /**
@@ -389,17 +446,16 @@ export class ObjectFieldSchema<
 		Kind extends FieldKind,
 		Types extends ImplicitAllowedTypes,
 		TCustomMetadata = unknown,
+		TProps extends FieldProps<TCustomMetadata> & {
+			readonly key: string;
+		} = FieldProps<TCustomMetadata> & { readonly key: string },
 	>
-	extends FieldSchemaAlpha<Kind, Types, TCustomMetadata>
+	extends FieldSchemaAlpha<Kind, Types, TCustomMetadata, TProps>
 	implements SimpleObjectFieldSchema
 {
 	public readonly storedKey: string;
 
-	public constructor(
-		kind: Kind,
-		allowedTypes: Types,
-		props: FieldProps<TCustomMetadata> & { readonly key: string },
-	) {
+	public constructor(kind: Kind, allowedTypes: Types, props: TProps) {
 		super(kind, allowedTypes, props);
 		this.storedKey = props.key;
 	}
@@ -594,7 +650,7 @@ export function objectSchema<
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
-			input: InsertableObjectFromSchemaRecord<T> | InternalTreeNode,
+			input: InsertableObjectFromSchemaRecordAlpha<T> | InternalTreeNode,
 		) => TreeObjectNode<T, TName>);
 	return CustomObjectNode as Output;
 }
@@ -665,7 +721,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 ??
@@ -673,7 +729,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 =

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

@@ -21,9 +21,40 @@ import type {
 import type {
 	TreeObjectNode,
 	SimpleKeyMap,
-	InsertableObjectFromSchemaRecord,
+	InsertableObjectFromSchemaRecordAlpha,
 } from "./objectNode.js";
 
+/**
+ * {@link (ObjectNodeSchema:interface)} with a workaround to avoid a specific known TypeScript issue which causes it to not be assignable to itself in some cases.
+ * @remarks
+ * If dealing with a schema whose inferred type includes this workaround (because it was produced by a schema factory API which uses it),
+ * if you need to explicitly state that type (for example when using {@link https://www.typescriptlang.org/tsconfig/#isolatedDeclarations | isolatedDeclarations}), it is best to keep this workaround.
+ * No other case should need to refer to this workaround type directly.
+ * See {@link ObjectNodeSchemaWorkaround.createFromInsertable} for details.
+ * @sealed
+ * @alpha
+ */
+export type ObjectNodeSchemaWorkaround<
+	TName extends string = string,
+	T extends
+		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
+	ImplicitlyConstructable extends boolean = boolean,
+	TCustomMetadata = unknown,
+> = ObjectNodeSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & {
+	/**
+	 * Typing checking workaround: not for for actual use.
+	 * @remarks
+	 * This API collides with {@link TreeNodeSchemaCore.createFromInsertable} to disable a type checking optimization which produces different and undesired results.
+	 * See {@link https://github.com/microsoft/TypeScript/issues/59049#issuecomment-2773459693} for more details.
+	 *
+	 * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,
+	 * @privateRemarks
+	 * See the above link and the tests in objectNode.spec.ts which reference it.
+	 * @system
+	 */
+	readonly createFromInsertable: unknown;
+};
+
 /**
  * A schema for {@link TreeObjectNode}s.
  * @sealed
@@ -39,7 +70,7 @@ export interface ObjectNodeSchema<
 			TName,
 			NodeKind.Object,
 			TreeObjectNode<T, TName>,
-			InsertableObjectFromSchemaRecord<T>,
+			object & InsertableObjectFromSchemaRecordAlpha<T>,
 			ImplicitlyConstructable,
 			T,
 			never,

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

@@ -127,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 => {