@fluidframework/tree 2.33.2 → 2.40.0-336023

package/src/simple-tree/mapNode.ts

@@ -15,10 +15,13 @@ import {
 	createFieldSchema,
 	FieldKind,
 	normalizeAllowedTypes,
+	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeNodeFromImplicitAllowedTypes,
+	type UnannotateImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
 	getKernel,
@@ -233,7 +236,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function mapSchema<
 	TName extends string,
-	const T extends ImplicitAllowedTypes,
+	const T extends ImplicitAnnotatedAllowedTypes,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -243,14 +246,19 @@ export function mapSchema<
 	useMapPrototype: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
 ) {
-	const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(info));
+	const lazyChildTypes = new Lazy(() =>
+		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
+	);
 	const lazyAllowedTypesIdentifiers = new Lazy(
 		() => new Set([...lazyChildTypes.value].map((type) => type.identifier)),
 	);
 
 	let unhydratedContext: Context;
 
-	class Schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
+	class Schema
+		extends CustomMapNodeBase<UnannotateImplicitAllowedTypes<T>>
+		implements TreeMapNode<UnannotateImplicitAllowedTypes<T>>
+	{
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,

package/src/simple-tree/mapNodeTypes.ts

@@ -4,7 +4,10 @@
  */
 
 import type { MapNodeInsertableData, TreeMapNode } from "./mapNode.js";
-import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import type {
+	ImplicitAnnotatedAllowedTypes,
+	UnannotateImplicitAllowedTypes,
+} from "./schemaTypes.js";
 import {
 	NodeKind,
 	type TreeNodeSchemaClass,
@@ -21,14 +24,14 @@ import type { SimpleMapNodeSchema } from "./simpleSchema.js";
  */
 export interface MapNodeCustomizableSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Map,
-			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<T>,
+			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,
@@ -42,14 +45,14 @@ export interface MapNodeCustomizableSchema<
  */
 export interface MapNodePojoEmulationSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaNonClass<
 			TName,
 			NodeKind.Map,
-			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<T>,
+			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,

package/src/simple-tree/objectNode.ts

@@ -29,6 +29,9 @@ import {
 	type NodeSchemaMetadata,
 	type FieldSchemaAlpha,
 	ObjectFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
+	unannotateSchemaRecord,
+	type UnannotateSchemaRecord,
 } from "./schemaTypes.js";
 import {
 	type TreeNodeSchema,
@@ -59,7 +62,7 @@ import type { SimpleObjectFieldSchema } from "./simpleSchema.js";
  * @remarks
  * Due to {@link https://github.com/microsoft/TypeScript/issues/43826}, we can't enable implicit construction of {@link TreeNode|TreeNodes} for setters.
  * Therefore code assigning to these fields must explicitly construct nodes using the schema's constructor or create method,
- * or using some other method like {@link TreeAlpha.create}.
+ * or using some other method like {@link (TreeAlpha:interface).create}.
  * @system @public
  */
 export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> =
@@ -92,7 +95,9 @@ export type TreeObjectNode<
 > = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
 
 /**
- * Type utility for determining whether or not an implicit field schema has a default value.
+ * Type utility for determining if an implicit field schema is known to have a default value.
+ *
+ * @remarks Yields `false` when unknown.
  *
  * @privateRemarks
  * TODO: Account for field schemas with default value providers.
@@ -100,9 +105,9 @@ export type TreeObjectNode<
  *
  * @system @public
  */
-export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSchema<
-	FieldKind.Optional | FieldKind.Identifier
->
+export type FieldHasDefault<T extends ImplicitFieldSchema> = [T] extends [
+	FieldSchema<FieldKind.Optional | FieldKind.Identifier>,
+]
 	? true
 	: false;
 
@@ -154,6 +159,18 @@ export type InsertableObjectFromSchemaRecord<
 			}
 		>;
 
+/**
+ * Helper used to remove annotations from a schema record and produce insertable objects,
+ *
+ * @privateremarks
+ * This calls {@link InsertableObjectFromSchemaRecord} in order to produce the insertable objects.
+ *
+ * @system @alpha
+ */
+export type InsertableObjectFromAnnotatedSchemaRecord<
+	T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+> = InsertableObjectFromSchemaRecord<UnannotateSchemaRecord<T>>;
+
 /**
  * Maps from simple field keys ("property" keys) to information about the field.
  *
@@ -354,7 +371,7 @@ abstract class CustomObjectNodeBase<
  */
 export function objectSchema<
 	TName extends string,
-	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
+	const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -368,12 +385,14 @@ export function objectSchema<
 	// Field set can't be modified after this since derived data is stored in maps.
 	Object.freeze(info);
 
+	const unannotatedInfo = unannotateSchemaRecord(info);
+
 	// Ensure no collisions between final set of property keys, and final set of stored keys (including those
 	// implicitly derived from property keys)
-	assertUniqueKeys(identifier, info);
+	assertUniqueKeys(identifier, unannotatedInfo);
 
 	// Performance optimization: cache property key => stored key and schema.
-	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(info);
+	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(unannotatedInfo);
 
 	const identifierFieldKeys: FieldKey[] = [];
 	for (const item of flexKeyMap.values()) {
@@ -390,17 +409,22 @@ export function objectSchema<
 	let customizable: boolean;
 	let unhydratedContext: Context;
 
-	class CustomObjectNode extends CustomObjectNodeBase<T> {
+	class CustomObjectNode extends CustomObjectNodeBase<UnannotateSchemaRecord<T>> {
 		public static readonly fields: ReadonlyMap<
 			string,
 			FieldSchemaAlpha & SimpleObjectFieldSchema
 		> = new Map(
 			Array.from(flexKeyMap, ([key, value]) => [
 				key as string,
-				new ObjectFieldSchema(value.schema.kind, value.schema.allowedTypes, {
-					...value.schema.props,
-					key: getStoredKey(key as string, value.schema),
-				}),
+				new ObjectFieldSchema(
+					value.schema.kind,
+					value.schema.allowedTypes,
+					(value.schema as FieldSchemaAlpha).annotatedAllowedTypes,
+					{
+						...value.schema.props,
+						key: getStoredKey(key as string, value.schema),
+					},
+				),
 			]),
 		);
 		public static readonly flexKeyMap: SimpleKeyMap = flexKeyMap;
@@ -513,8 +537,8 @@ export function objectSchema<
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
-			input: InsertableObjectFromSchemaRecord<T> | InternalTreeNode,
-		) => TreeObjectNode<T, TName>);
+			input: InsertableObjectFromAnnotatedSchemaRecord<T> | InternalTreeNode,
+		) => TreeObjectNode<UnannotateSchemaRecord<T>, TName>);
 	return CustomObjectNode as Output;
 }
 

package/src/simple-tree/objectNodeTypes.ts

@@ -6,10 +6,14 @@
 import type { RestrictiveStringRecord } from "../util/index.js";
 import type {
 	TreeObjectNode,
-	InsertableObjectFromSchemaRecord,
 	SimpleKeyMap,
+	InsertableObjectFromAnnotatedSchemaRecord,
 } from "./objectNode.js";
-import type { ImplicitFieldSchema, FieldSchemaAlpha } from "./schemaTypes.js";
+import type {
+	FieldSchemaAlpha,
+	ImplicitAnnotatedFieldSchema,
+	UnannotateSchemaRecord,
+} from "./schemaTypes.js";
 import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "./core/index.js";
 import type { FieldKey } from "../core/index.js";
 import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSchema.js";
@@ -22,14 +26,14 @@ import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSc
 export interface ObjectNodeSchema<
 	out TName extends string = string,
 	in out T extends
-		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
+		RestrictiveStringRecord<ImplicitAnnotatedFieldSchema> = RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
 	ImplicitlyConstructable extends boolean = boolean,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Object,
-			TreeObjectNode<T, TName>,
-			InsertableObjectFromSchemaRecord<T>,
+			TreeObjectNode<UnannotateSchemaRecord<T>, TName>,
+			InsertableObjectFromAnnotatedSchemaRecord<T>,
 			ImplicitlyConstructable,
 			T,
 			never,