@fluidframework/tree 2.4.0 → 2.5.0-302463

package/src/simple-tree/api/schemaCreationUtilities.ts

@@ -13,8 +13,10 @@ import type {
 	InternalTreeNode,
 	NodeKind,
 	TreeNode,
+	TreeNodeSchema,
 	TreeNodeSchemaClass,
 } from "../core/index.js";
+import type { UnionToTuple } from "../../util/index.js";
 
 /*
  * This file does two things:
@@ -40,7 +42,7 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 	name: TName,
 ) {
 	class SingletonSchema extends factory.object(name, {}) {
-		public constructor(data?: InternalTreeNode) {
+		public constructor(data?: InternalTreeNode | Record<string, never>) {
 			super(data ?? {});
 		}
 		public get value(): TName {
@@ -48,7 +50,7 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 		}
 	}
 
-	type NodeType = TreeNode & { readonly value: TName };
+	type SingletonNodeType = TreeNode & { readonly value: TName };
 
 	// Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
 	// for the private brand field of TreeNode.
@@ -58,11 +60,13 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 	const toReturn: TreeNodeSchemaClass<
 		ScopedSchemaName<TScope, TName>,
 		NodeKind.Object,
-		NodeType,
-		never,
+		SingletonNodeType,
+		Record<string, never>,
 		true
 	> &
-		(new () => NodeType) = SingletonSchema;
+		(new (
+			data?: InternalTreeNode | Record<string, never>,
+		) => SingletonNodeType) = SingletonSchema;
 
 	return toReturn;
 }
@@ -84,15 +88,14 @@ export function singletonSchema<TScope extends string, TName extends string | nu
  * // Define the schema for each member of the enum using a nested scope to group them together.
  * const ModeNodes = adaptEnum(new SchemaFactory(`${schemaFactory.scope}.Mode`), Mode);
  * // Defined the types of the nodes which correspond to this the schema.
- * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;
+ * type ModeNodes = NodeFromSchema<(typeof ModeNodes.schema)[number]>;
  * // An example schema which has an enum as a child.
  * class Parent extends schemaFactory.object("Parent", {
- * 	// typedObjectValues extracts a list of all the fields of ModeNodes, which are the schema for each enum member.
- * 	// This means any member of the enum is allowed in this field.
- * 	mode: typedObjectValues(ModeNodes),
+ * 	// adaptEnum's return value has a ".schema" property can be use as an `AllowedTypes` array allowing any of the members of the enum.
+ * 	mode: ModeNodes.schema,
  * }) {}
  *
- * // Example usage of enum-based nodes, showing what type to use and that `.value` can be used to read out the enum value.
+ * // Example usage of enum based nodes, showing what type to use and that `.value` can be used to read out the enum value.
  * function getValue(node: ModeNodes): Mode {
  * 	return node.value;
  * }
@@ -131,35 +134,36 @@ export function adaptEnum<
 			typeof singletonSchema<TScope, TEnum[Property]>
 		>;
 	};
+
+	type SchemaArray = UnionToTuple<TOut[keyof TEnum]>;
+	const schemaArray: TreeNodeSchema[] = [];
+
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 	const factoryOut = <TValue extends Values>(value: TValue) => {
 		return new out[inverse.get(value) ?? fail("missing enum value")]() as NodeFromSchema<
 			ReturnType<typeof singletonSchema<TScope, TValue>>
 		>;
 	};
-	const out = factoryOut as typeof factoryOut & TOut;
+	const out = factoryOut as typeof factoryOut & TOut & { readonly schema: SchemaArray };
 	for (const [key, value] of Object.entries(members)) {
+		const schema = singletonSchema(factory, value);
+		schemaArray.push(schema);
 		Object.defineProperty(out, key, {
 			enumerable: true,
 			configurable: false,
 			writable: false,
-			value: singletonSchema(factory, value),
+			value: schema,
 		});
 	}
 
-	return out;
-}
+	Object.defineProperty(out, "schema", {
+		enumerable: true,
+		configurable: false,
+		writable: false,
+		value: schemaArray,
+	});
 
-/**
- * `Object.values`, but with more specific types.
- * @remarks
- * Useful with collections of schema, like those returned by {@link adaptEnum} or {@link enumFromStrings}.
- * @alpha
- */
-export function typedObjectValues<TKey extends string, TValues>(
-	object: Record<TKey, TValues>,
-): TValues[] {
-	return Object.values(object);
+	return out;
 }
 
 /**
@@ -171,44 +175,63 @@ export function typedObjectValues<TKey extends string, TValues>(
  * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.
  * @example
  * ```typescript
+ * const schemaFactory = new SchemaFactory("com.myApp");
  * const Mode = enumFromStrings(schemaFactory, ["Fun", "Cool"]);
- * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;
+ * type Mode = NodeFromSchema<(typeof Mode.schema)[number]>;
  * const nodeFromString: Mode = Mode("Fun");
  * const nodeFromSchema: Mode = new Mode.Fun();
- * const nameFromNode = nodeFromSchema.value;
  *
- * class Parent extends schemaFactory.object("Parent", { mode: typedObjectValues(Mode) }) {}
+ * // Schema nodes have a strongly typed `.value` property.
+ * const nameFromNode: "Fun" | "Cool" = nodeFromSchema.value;
+ *
+ * class Parent extends schemaFactory.object("Parent", { mode: Mode.schema }) {}
  * ```
  * @see {@link adaptEnum} for a similar function that works on enums instead of arrays of strings.
  * @alpha
  */
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function enumFromStrings<TScope extends string, const Members extends string>(
-	factory: SchemaFactory<TScope>,
-	members: readonly Members[],
-) {
+export function enumFromStrings<
+	TScope extends string,
+	const Members extends readonly string[],
+>(factory: SchemaFactory<TScope>, members: Members) {
 	const names = new Set(members);
 	if (names.size !== members.length) {
 		throw new UsageError("All members of enums must have distinct names");
 	}
 
-	type TOut = Record<Members, ReturnType<typeof singletonSchema<TScope, Members>>>;
+	type TOut = Record<
+		Members[number],
+		ReturnType<typeof singletonSchema<TScope, Members[number]>>
+	>;
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-	const factoryOut = <TValue extends Members>(value: TValue) => {
+	const factoryOut = <TValue extends Members[number]>(value: TValue) => {
 		return new out[value]() as NodeFromSchema<
 			ReturnType<typeof singletonSchema<TScope, TValue>>
 		>;
 	};
-	const out = factoryOut as typeof factoryOut & TOut;
+
+	type SchemaArray = UnionToTuple<TOut[Members[number]]>;
+	const schemaArray: TreeNodeSchema[] = [];
+
+	const out = factoryOut as typeof factoryOut & TOut & { readonly schema: SchemaArray };
 	for (const name of members) {
+		const schema = singletonSchema(factory, name);
+		schemaArray.push(schema);
 		Object.defineProperty(out, name, {
 			enumerable: true,
 			configurable: false,
 			writable: false,
-			value: singletonSchema(factory, name),
+			value: schema,
 		});
 	}
 
+	Object.defineProperty(out, "schema", {
+		enumerable: true,
+		configurable: false,
+		writable: false,
+		value: schemaArray,
+	});
+
 	return out;
 }
 

package/src/simple-tree/api/schemaFactory.ts

@@ -120,6 +120,10 @@ export type ScopedSchemaName<
  * Typically this is just `string` but it is also possible to use `string` or `number` based enums if you prefer to identify your types that way.
  *
  * @remarks
+ * For details related to inputting data constrained by schema (including via assignment), and how non-exact schema types are handled in general refer to {@link Input}.
+ * For information about recursive schema support, see methods postfixed with "recursive" and {@link ValidateRecursiveSchema}.
+ * To apply schema defined with this factory to a tree, see {@link ViewableTree.viewWith} and {@link TreeViewConfiguration}.
+ *
  * All schema produced by this factory get a {@link TreeNodeSchemaCore.identifier|unique identifier} by combining the {@link SchemaFactory.scope} with the schema's `Name`.
  * The `Name` part may be explicitly provided as a parameter, or inferred as a structural combination of the provided types.
  * The APIs which use this second approach, structural naming, also deduplicate all equivalent calls.

package/src/simple-tree/api/simpleSchemaToJsonSchema.ts

@@ -97,7 +97,7 @@ function convertArrayNodeSchema(schema: SimpleArrayNodeSchema): JsonArrayNodeSch
 	});
 
 	const items: JsonFieldSchema =
-		allowedTypes.length === 1 ? allowedTypes[0] ?? oob() : { anyOf: allowedTypes };
+		allowedTypes.length === 1 ? (allowedTypes[0] ?? oob()) : { anyOf: allowedTypes };
 
 	return {
 		type: "array",
@@ -144,7 +144,7 @@ function convertObjectNodeSchema(schema: SimpleObjectNodeSchema): JsonObjectNode
 
 		const output: Mutable<JsonFieldSchema> =
 			allowedTypes.length === 1
-				? allowedTypes[0] ?? oob()
+				? (allowedTypes[0] ?? oob())
 				: {
 						anyOf: allowedTypes,
 					};
@@ -180,7 +180,7 @@ function convertMapNodeSchema(schema: SimpleMapNodeSchema): JsonMapNodeSchema {
 		patternProperties: {
 			"^.*$":
 				allowedTypes.length === 1
-					? allowedTypes[0] ?? oob()
+					? (allowedTypes[0] ?? oob())
 					: {
 							anyOf: allowedTypes,
 						},

package/src/simple-tree/api/tree.ts

@@ -11,11 +11,14 @@ import type { Listenable } from "../../events/index.js";
 
 import {
 	type ImplicitFieldSchema,
+	type InsertableField,
 	type InsertableTreeFieldFromImplicitField,
 	type TreeFieldFromImplicitField,
+	type TreeLeafValue,
+	type UnsafeUnknownSchema,
 	FieldKind,
 } from "../schemaTypes.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNode, type TreeNodeSchema } from "../core/index.js";
 import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
@@ -190,8 +193,9 @@ export interface ITreeViewConfiguration<
  * Configuration for {@link ViewableTree.viewWith}.
  * @sealed @public
  */
-export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema>
-	implements Required<ITreeViewConfiguration<TSchema>>
+export class TreeViewConfiguration<
+	const TSchema extends ImplicitFieldSchema = ImplicitFieldSchema,
+> implements Required<ITreeViewConfiguration<TSchema>>
 {
 	protected _typeCheck!: MakeNominal;
 
@@ -363,7 +367,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
  * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
  * @sealed @public
  */
-export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
+export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
 	/**
 	 * The current root of the tree.
 	 *
@@ -424,6 +428,25 @@ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposab
 	readonly schema: TSchema;
 }
 
+/**
+ * {@link TreeView} with proposed changes to the schema aware typing to allow use with `UnsafeUnknownSchema`.
+ * @alpha
+ */
+export interface TreeViewAlpha<
+	in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema,
+> extends Omit<
+		TreeView<TSchema extends ImplicitFieldSchema ? TSchema : ImplicitFieldSchema>,
+		"root" | "initialize"
+	> {
+	get root(): TSchema extends ImplicitFieldSchema
+		? TreeFieldFromImplicitField<TSchema>
+		: TreeLeafValue | TreeNode;
+
+	set root(newRoot: InsertableField<TSchema>);
+
+	initialize(content: InsertableField<TSchema>): void;
+}
+
 /**
  * Information about a view schema's compatibility with the document's stored schema.
  *

package/src/simple-tree/api/treeApiBeta.ts

@@ -12,7 +12,11 @@ import {
 	type Unhydrated,
 	type WithType,
 } from "../core/index.js";
-import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../schemaTypes.js";
+import type {
+	ImplicitFieldSchema,
+	TreeFieldFromImplicitField,
+	UnsafeUnknownSchema,
+} from "../schemaTypes.js";
 import { treeNodeApi } from "./treeNodeApi.js";
 import { createFromCursor, cursorFromInsertable } from "./create.js";
 import type { ITreeCursorSynchronous } from "../../core/index.js";
@@ -145,7 +149,7 @@ export const TreeBeta: {
 		if (!kernel.isHydrated()) {
 			return createFromCursor(
 				kernel.schema,
-				cursorFromInsertable(kernel.schema, node),
+				cursorFromInsertable<UnsafeUnknownSchema>(kernel.schema, node),
 			) as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
 		}
 

package/src/simple-tree/api/typesUnsafe.ts

@@ -3,27 +3,28 @@
  * Licensed under the MIT License.
  */
 
-import type { RestrictiveStringRecord, _InlineTrick } from "../../util/index.js";
+import type { RestrictiveStringRecord, UnionToIntersection } from "../../util/index.js";
 
 import type {
-	AllowedTypes,
 	ApplyKind,
+	ApplyKindInput,
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	ImplicitFieldSchema,
-	NodeFromSchema,
-	TreeNodeFromImplicitAllowedTypes,
+	TreeLeafValue,
 } from "../schemaTypes.js";
 import type {
 	NodeKind,
-	TreeNodeSchema,
 	WithType,
 	TreeNode,
 	Unhydrated,
+	InternalTreeNode,
+	TreeNodeSchema,
+	TreeNodeSchemaCore,
 } from "../core/index.js";
-import type { TreeArrayNodeBase, TreeArrayNode } from "../arrayNode.js";
-import type { FlexListToUnion } from "../flexList.js";
+import type { TreeArrayNodeBase } from "../arrayNode.js";
+import type { FlexListToUnion, LazyItem } from "../flexList.js";
 
 /*
  * TODO:
@@ -59,6 +60,65 @@ export type ObjectFromSchemaRecordUnsafe<
 	-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
 };
 
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchema}.
+ * @remarks
+ * Do not use this type directly: it is only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export type TreeNodeSchemaUnsafe<
+	Name extends string = string,
+	Kind extends NodeKind = NodeKind,
+	TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown,
+	TBuild = never,
+	ImplicitlyConstructable extends boolean = boolean,
+	Info = unknown,
+> =
+	| TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>
+	| TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
+
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchemaClass}.
+ * @remarks
+ * Do not use this type directly: it is only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export interface TreeNodeSchemaClassUnsafe<
+	out Name extends string,
+	out Kind extends NodeKind,
+	// TODO: maybe this can be more specific (exclude leaves)
+	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
+	in TInsertable,
+	out ImplicitlyConstructable extends boolean,
+	out Info,
+> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+	/**
+	 * Constructs an {@link Unhydrated} node with this schema.
+	 * @remarks
+	 * This constructor is also used internally to construct hydrated nodes with a different parameter type.
+	 * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.
+	 * @sealed
+	 */
+	new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
+}
+
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchemaNonClass}.
+ * @remarks
+ * Do not use this type directly: it is only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export interface TreeNodeSchemaNonClassUnsafe<
+	out Name extends string,
+	out Kind extends NodeKind,
+	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
+	in TInsertable,
+	out ImplicitlyConstructable extends boolean,
+	out Info = unknown,
+> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+	create(data: TInsertable): TNode;
+}
+
 /**
  * {@link Unenforced} version of {@link TreeObjectNode}.
  * @remarks
@@ -78,11 +138,19 @@ export type TreeObjectNodeUnsafe<
  */
 export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> =
 	TSchema extends FieldSchemaUnsafe<infer Kind, infer Types>
-		? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false>
+		? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind>
 		: TSchema extends ImplicitAllowedTypes
 			? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema>
 			: unknown;
 
+/**
+ * {@link Unenforced} version of {@link AllowedTypes}.
+ * @remarks
+ * Do not use this type directly: it is only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
+
 /**
  * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.
  * @remarks
@@ -91,36 +159,60 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
  */
 export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends ImplicitAllowedTypes
-	? TreeNodeFromImplicitAllowedTypes<TSchema>
-	: TSchema extends TreeNodeSchema
-		? NodeFromSchema<TSchema>
-		: TSchema extends AllowedTypes
-			? NodeFromSchema<FlexListToUnion<TSchema>>
-			: unknown;
+> = TSchema extends TreeNodeSchemaUnsafe
+	? NodeFromSchemaUnsafe<TSchema>
+	: TSchema extends AllowedTypesUnsafe
+		? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>>
+		: unknown;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
+ * @see {@link Input}
  * @remarks
  * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
  * @system @public
  */
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends AllowedTypes
-	? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>
-	: InsertableTypedNodeUnsafe<TSchema>;
+> = [TSchema] extends [TreeNodeSchemaUnsafe]
+	? InsertableTypedNodeUnsafe<TSchema>
+	: [TSchema] extends [AllowedTypesUnsafe]
+		? InsertableTreeNodeFromAllowedTypesUnsafe<TSchema>
+		: never;
+
+/**
+ * {@link Unenforced} version of {@link InsertableTreeNodeFromAllowedTypes}.
+ * @see {@link Input}
+ * @system @public
+ */
+export type InsertableTreeNodeFromAllowedTypesUnsafe<
+	TList extends Unenforced<AllowedTypesUnsafe>,
+> = TList extends readonly [
+	LazyItem<infer TSchema extends TreeNodeSchemaUnsafe>,
+	...infer Rest extends AllowedTypesUnsafe,
+]
+	? InsertableTypedNodeUnsafe<TSchema> | InsertableTreeNodeFromAllowedTypesUnsafe<Rest>
+	: never;
 
 /**
  * {@link Unenforced} version of {@link InsertableTypedNode}.
+ * @see {@link Input}
  * @remarks
  * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @privateRemarks
+ * TODO:
+ * This is less strict than InsertableTypedNode when given non-exact schema to avoid compilation issues.
+ * This should probably be fixed or documented somehow.
  * @system @public
  */
-export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
-	| Unhydrated<NodeFromSchemaUnsafe<T>>
-	| (T extends { implicitlyConstructable: true } ? NodeBuilderDataUnsafe<T> : never),
-][_InlineTrick];
+export type InsertableTypedNodeUnsafe<
+	TSchema extends Unenforced<TreeNodeSchemaUnsafe>,
+	T = UnionToIntersection<TSchema>,
+> =
+	| (T extends TreeNodeSchemaUnsafe<string, NodeKind, TreeNode | TreeLeafValue, never, true>
+			? NodeBuilderDataUnsafe<T>
+			: never)
+	| (T extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<T> : never);
 
 /**
  * {@link Unenforced} version of {@link NodeFromSchema}.
@@ -129,7 +221,7 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
  * @system @public
  */
 export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
+	T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -138,7 +230,7 @@ export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * @system @public
  */
 export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+	T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
 
 /**
  * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.
@@ -149,8 +241,7 @@ export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
 export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>
 	extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		TreeArrayNode
+		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>
 	> {}
 
 /**
@@ -235,6 +326,7 @@ export type FieldHasDefaultUnsafe<T extends Unenforced<ImplicitFieldSchema>> =
 
 /**
  * {@link Unenforced} version of `InsertableObjectFromSchemaRecord`.
+ * @see {@link Input}
  * @remarks
  * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
  * @system @public
@@ -256,15 +348,19 @@ export type InsertableObjectFromSchemaRecordUnsafe<
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeFieldFromImplicitField}.
+ * @see {@link Input}
  * @remarks
  * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
  * @system @public
  */
 export type InsertableTreeFieldFromImplicitFieldUnsafe<
-	TSchema extends Unenforced<ImplicitFieldSchema>,
-> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types>
-	? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true>
-	: InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
+	TSchemaInput extends Unenforced<ImplicitFieldSchema>,
+	TSchema = UnionToIntersection<TSchemaInput>,
+> = [TSchema] extends [FieldSchemaUnsafe<infer Kind, infer Types>]
+	? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true>
+	: [TSchema] extends [ImplicitAllowedTypes]
+		? InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>
+		: never;
 
 /**
  * {@link Unenforced} version of {@link FieldSchema}.