@fluidframework/tree 2.52.0 → 2.53.0

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

@@ -8,7 +8,7 @@ import { allowsRepoSuperset, defaultSchemaPolicy } from "../../feature-libraries
 
 import type { SchemaCompatibilityStatus } from "./tree.js";
 import { getDiscrepanciesInAllowedContent } from "./discrepancies.js";
-import { toStoredSchema } from "../toStoredSchema.js";
+import { toUpgradeSchema } from "../toStoredSchema.js";
 import type { TreeSchema } from "./configuration.js";
 
 /**
@@ -51,18 +51,14 @@ export class SchemaCompatibilityTester {
 			break;
 		}
 
-		const canUpgrade = allowsRepoSuperset(
-			policy,
-			stored,
-			toStoredSchema(this.viewSchema.root),
-		);
+		const wouldUpgradeTo = toUpgradeSchema(this.viewSchema.root);
+
+		const canUpgrade = allowsRepoSuperset(policy, stored, wouldUpgradeTo);
 
 		// If true, then upgrading has no effect on what can be stored in the document.
 		// TODO: This should likely be changed to indicate up a schema upgrade would be a no-op, including stored schema metadata.
 		const isEquivalent =
-			canView &&
-			canUpgrade &&
-			allowsRepoSuperset(policy, toStoredSchema(this.viewSchema.root), stored);
+			canView && canUpgrade && allowsRepoSuperset(policy, wouldUpgradeTo, stored);
 
 		return {
 			canView,

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

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
@@ -29,7 +28,6 @@ import type {
 	TreeNodeSchemaBoth,
 	UnhydratedFlexTreeNode,
 	NodeSchemaMetadata,
-	ImplicitAnnotatedAllowedTypes,
 	UnannotateImplicitAllowedTypes,
 	ImplicitAllowedTypes,
 	InsertableTreeNodeFromImplicitAllowedTypes,
@@ -40,6 +38,8 @@ import {
 	nullSchema,
 	numberSchema,
 	stringSchema,
+	// This import prevents a large number of LeafSchema references in the API reports from showing up as LeafSchema_2.
+	// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars
 	type LeafSchema,
 } from "../leafNodeSchema.js";
 import {
@@ -57,20 +57,20 @@ import {
 	FieldKind,
 	type FieldSchema,
 	type ImplicitFieldSchema,
+	// This import prevents a large number of FieldProps references in the API reports from showing up as FieldProps_2.
+	// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars
 	type FieldProps,
 	createFieldSchema,
 	type DefaultProvider,
 	getDefaultProvider,
-	type FieldSchemaAlpha,
-	type FieldPropsAlpha,
 } from "../fieldSchema.js";
 
-import { createFieldSchemaUnsafe } from "./schemaFactoryRecursive.js";
-import type { System_Unsafe, FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
+import type { System_Unsafe } from "./typesUnsafe.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 import type { FlexTreeHydratedContextMinimal } from "../../feature-libraries/index.js";
 import { unhydratedFlexTreeFromInsertable } from "../unhydratedFlexTreeFromInsertable.js";
+import { type SchemaStatics, schemaStatics } from "./schemaStatics.js";
 
 /**
  * Gets the leaf domain schema compatible with a given {@link TreeValue}.
@@ -171,250 +171,6 @@ export type ScopedSchemaName<
 > = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;
 // > = `${TScope extends undefined ? "" : `${TScope}.`}${TName}`;
 
-/**
- * Stateless APIs exposed via {@link SchemaFactory} as both instance properties and as statics.
- * @privateRemarks
- * We have no way to make linkable members which exist both as statics and instance properties since API-Extractor does not support this.
- * As a workaround, we have this type as a third place which can be linked.
- * @system @sealed @public
- */
-export interface SchemaStatics {
-	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `string`.
-	 *
-	 * @remarks
-	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
-	 *
-	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
-	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
-	 */
-	readonly string: LeafSchema<"string", string>;
-
-	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `number`.
-	 *
-	 * @remarks
-	 * The number is a {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format | double-precision 64-bit binary format IEEE 754} value, however there are some exceptions:
-	 *
-	 * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
-	 *
-	 * - `-0` may be converted to `0` in some cases.
-	 *
-	 * These limitations match the limitations of JSON.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
-	 */
-	readonly number: LeafSchema<"number", number>;
-
-	/**
-	 * {@link TreeNodeSchema} for holding a boolean.
-	 */
-	readonly boolean: LeafSchema<"boolean", boolean>;
-
-	/**
-	 * {@link TreeNodeSchema} for JavaScript `null`.
-	 *
-	 * @remarks
-	 * There are good {@link https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null | reasons to avoid using null} in JavaScript, however sometimes it is desired.
-	 * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
-	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
-	 */
-	// eslint-disable-next-line @rushstack/no-new-null
-	readonly null: LeafSchema<"null", null>;
-
-	/**
-	 * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
-	 */
-	readonly handle: LeafSchema<"handle", IFluidHandle>;
-
-	/**
-	 * {@link AllowedTypes} for holding any of the leaf types.
-	 */
-	readonly leaves: readonly [
-		SchemaStatics["string"],
-		SchemaStatics["number"],
-		SchemaStatics["boolean"],
-		SchemaStatics["null"],
-		SchemaStatics["handle"],
-	];
-
-	/**
-	 * Make a field optional instead of the default, which is required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
-	 */
-	readonly optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	) => FieldSchema<FieldKind.Optional, T, TCustomMetadata>;
-
-	/**
-	 * Make a field explicitly required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @remarks
-	 * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
-	 * and allows associating custom {@link FieldProps | properties} with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
-	 */
-	readonly required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	) => FieldSchema<FieldKind.Required, T, TCustomMetadata>;
-
-	/**
-	 * {@link SchemaStatics.optional} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaStatics.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
-	 */
-	readonly optionalRecursive: <
-		const T extends System_Unsafe.ImplicitAllowedTypesUnsafe,
-		const TCustomMetadata = unknown,
-	>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, T, TCustomMetadata>;
-
-	/**
-	 * {@link SchemaStatics.required} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaStatics.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
-	 */
-	readonly requiredRecursive: <
-		const T extends System_Unsafe.ImplicitAllowedTypesUnsafe,
-		const TCustomMetadata = unknown,
-	>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Required, T, TCustomMetadata>;
-}
-
-const defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => []);
-
-// The following overloads for optional and required are used to get around the fact that
-// the compiler can't infer that UnannotateImplicitAllowedTypes<T> is equal to T when T is known to extend ImplicitAllowedTypes
-
-function optional<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata>;
-
-function optional<
-	const T extends ImplicitAnnotatedAllowedTypes,
-	const TCustomMetadata = unknown,
->(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T>, TCustomMetadata>;
-
-function optional<
-	const T extends ImplicitAnnotatedAllowedTypes,
-	const TCustomMetadata = unknown,
->(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T>, TCustomMetadata> {
-	return createFieldSchema(FieldKind.Optional, t, {
-		defaultProvider: defaultOptionalProvider,
-		...props,
-	});
-}
-
-function required<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata>;
-
-function required<
-	const T extends ImplicitAnnotatedAllowedTypes,
-	const TCustomMetadata = unknown,
->(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T>, TCustomMetadata>;
-
-function required<
-	const T extends ImplicitAnnotatedAllowedTypes,
-	const TCustomMetadata = unknown,
->(
-	t: T,
-	props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T>, TCustomMetadata> {
-	return createFieldSchema(FieldKind.Required, t, props);
-}
-
-/**
- * Implementation of {@link SchemaStatics}.
- * @remarks
- * Entries can use more specific types than {@link SchemaStatics} requires to be more useful for non-public consumers.
- * Additional non-public members are in {@link schemaStatics}.
- */
-export const schemaStaticsBase = {
-	string: stringSchema,
-	number: numberSchema,
-	boolean: booleanSchema,
-	null: nullSchema,
-	handle: handleSchema,
-	leaves: [stringSchema, numberSchema, booleanSchema, nullSchema, handleSchema],
-
-	optional,
-
-	required,
-
-	optionalRecursive: <
-		const T extends System_Unsafe.ImplicitAllowedTypesUnsafe,
-		const TCustomMetadata = unknown,
-	>(
-		t: T,
-		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata> => {
-		return createFieldSchemaUnsafe(FieldKind.Optional, t, {
-			defaultProvider: defaultOptionalProvider,
-			...props,
-		});
-	},
-
-	requiredRecursive: <
-		const T extends System_Unsafe.ImplicitAllowedTypesUnsafe,
-		const TCustomMetadata = unknown,
-	>(
-		t: T,
-		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata> => {
-		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
-	},
-} as const satisfies SchemaStatics;
-
-/**
- * Unstable extensions to {@link schemaStaticsBase}.
- */
-export const schemaStatics = {
-	...schemaStaticsBase,
-	identifier: <const TCustomMetadata = unknown>(
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlpha<FieldKind.Identifier, typeof stringSchema, TCustomMetadata> => {
-		return createFieldSchema(FieldKind.Identifier, stringSchema, props);
-	},
-} as const;
-
 const schemaStaticsPublic: SchemaStatics = schemaStatics;
 
 // TODO:

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

@@ -18,12 +18,12 @@ import {
 import {
 	defaultSchemaFactoryObjectOptions,
 	SchemaFactory,
-	schemaStatics,
 	structuralName,
 	type NodeSchemaOptionsAlpha,
 	type SchemaFactoryObjectOptions,
 	type ScopedSchemaName,
 } from "./schemaFactory.js";
+import { schemaStatics } from "./schemaStatics.js";
 import type { ImplicitAnnotatedFieldSchema, ImplicitFieldSchema } from "../fieldSchema.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
 import type {
@@ -35,7 +35,10 @@ import type {
 	WithType,
 	ImplicitAllowedTypes,
 	ImplicitAnnotatedAllowedTypes,
+	AnnotatedAllowedType,
+	LazyItem,
 } from "../core/index.js";
+import { normalizeToAnnotatedAllowedType, createSchemaUpgrade } from "../core/index.js";
 import type {
 	ArrayNodeCustomizableSchemaUnsafe,
 	MapNodeCustomizableSchemaUnsafe,
@@ -44,6 +47,166 @@ import type {
 } from "./typesUnsafe.js";
 import type { SimpleObjectNodeSchema } from "../simpleSchema.js";
 
+// This import prevents a large number of type references in the API reports from showing up as *_2.
+/* eslint-disable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates */
+import type {
+	FieldProps,
+	FieldSchemaAlpha,
+	FieldPropsAlpha,
+	FieldKind,
+} from "../fieldSchema.js";
+import type { LeafSchema } from "../leafNodeSchema.js";
+import type { SimpleLeafNodeSchema } from "../simpleSchema.js";
+import type { UnannotateImplicitAllowedTypes } from "../core/index.js";
+import type { FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
+/* eslint-enable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates */
+
+/**
+ * Stateless APIs exposed via {@link SchemaFactoryAlpha} as both instance properties and as statics.
+ * @remarks
+ * See {@link SchemaStatics} for why this is useful.
+ * @system @sealed @alpha
+ */
+export interface SchemaStaticsAlpha {
+	/**
+	 * Declares a staged type in a set of {@link AllowedTypes}.
+	 *
+	 * @remarks
+	 * Staged allowed types add support for loading documents which may or may not permit an allowed type in a location in a schema.
+	 * This allows for an incremental rollout of a schema change to add a {@link TreeNodeSchema} to an {@link AllowedTypes} without breaking cross version collaboration.
+	 *
+	 * Once enough clients have the type staged (and thus can read documents which allow it), documents can start being created and upgraded to allow the staged type.
+	 * This is done by deploying a new version of the app which removes the `staged` wrapper around the allowed type in the the schema definition.
+	 * This will also require {@link TreeView.upgradeSchema|upgrading the schema} for existing documents.
+	 *
+	 * Using a staged allowed type in a schema is just like using the schema as an allowed type with the following exceptions:
+	 *
+	 * 1. {@link TreeView.initialize} will omit the staged allowed type from the newly created stored schema.
+	 * 2. {@link TreeView.upgradeSchema} will omit the staged allowed type from the the upgraded stored schema.
+	 * 3. When evaluating {@link TreeView.compatibility}, it will be viewable even if the staged allowed type is not present in the stored schema's corresponding allowed types.
+	 * 4. Because of the above, it is possible to get errors when inserting content which uses the staged allowed type when inserting the content into a tree who's stored schema does not permit it.
+	 *
+	 * Currently, `staged` is not supported in the recursive type APIs: this is a known limitation which future versions of the API will address.
+	 *
+	 * @example
+	 * Suppose you have a schema which has a field that allows some type `A`, but you want to add support for type `B`.
+	 *
+	 * The first change is to used to mark the new type as staged, replacing `A` in the schema with `[A, SchemaStaticsAlpha.staged(B)]`.
+	 * Once this is done, and any code which reads contents from documents is updated to handle any `B` content that may be present, this version of the code can be deployed.
+	 *
+	 * Once all users have the above changes, the schema can be updated again to `[A, B]`, and the app can be updated to allow creating of `B` content.
+	 * This updated version of the app will need to call {@link TreeView.upgradeSchema} when opening documents created by earlier versions.
+	 *
+	 * Adding a `B` schema as an option in the root could look like this:
+	 * ```typescript
+	 * const factory = new SchemaFactoryAlpha("test");
+	 * class A extends factory.objectAlpha("A", {}) {}
+	 * class B extends factory.objectAlpha("B", {}) {}
+	 *
+	 * // Does not support B
+	 * const configBefore = new TreeViewConfigurationAlpha({
+	 * 	schema: A,
+	 * });
+	 *
+	 * // Supports documents with or without B
+	 * const configStaged = new TreeViewConfigurationAlpha({
+	 * 	// Adds staged support for B.
+	 * 	// Currently this requires wrapping the root field with `SchemaFactoryAlpha.required`:
+	 * 	// this is normally implicitly included, but is currently required while the "staged" APIs are `@alpha`.
+	 * 	schema: SchemaFactoryAlpha.required([A, SchemaFactoryAlpha.staged(B)]),
+	 * });
+	 *
+	 * // Only supports documents with A and B: can be used to upgrade schema to add B.
+	 * const configAfter = new TreeViewConfigurationAlpha({
+	 * 	schema: [A, B],
+	 * });
+	 * ```
+	 * @example
+	 * Below is a full example of how the schema migration process works.
+	 * This can also be found in our {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts | tests}.
+	 * ```typescript
+	 * // Schema A: only number allowed
+	 * const schemaA = SchemaFactoryAlpha.optional([SchemaFactoryAlpha.number]);
+	 *
+	 * // Schema B: number or string (string is staged)
+	 * const schemaB = SchemaFactoryAlpha.optional([
+	 * 	SchemaFactoryAlpha.number,
+	 * 	SchemaFactoryAlpha.staged(SchemaFactoryAlpha.string),
+	 * ]);
+	 *
+	 * // Schema C: number or string, both fully allowed
+	 * const schemaC = SchemaFactoryAlpha.optional([
+	 * 	SchemaFactoryAlpha.number,
+	 * 	SchemaFactoryAlpha.string,
+	 * ]);
+	 *
+	 * // Initialize with schema A.
+	 * const configA = new TreeViewConfiguration({
+	 * 	schema: schemaA,
+	 * });
+	 * const viewA = treeA.viewWith(configA);
+	 * viewA.initialize(5);
+	 *
+	 * // Since we are running all the different versions of the app in the same process making changes synchronously,
+	 * // an explicit flush is needed to make them available to each other.
+	 * synchronizeTrees();
+	 *
+	 * assert.deepEqual(viewA.root, 5);
+	 *
+	 * // View the same document with a second tree using schema B.
+	 * const configB = new TreeViewConfiguration({
+	 * 	schema: schemaB,
+	 * });
+	 * const viewB = treeB.viewWith(configB);
+	 * // B cannot write strings to the root.
+	 * assert.throws(() => (viewB.root = "test"));
+	 *
+	 * // View the same document with a third tree using schema C.
+	 * const configC = new TreeViewConfiguration({
+	 * 	schema: schemaC,
+	 * });
+	 * const viewC = treeC.viewWith(configC);
+	 * // Upgrade to schema C
+	 * viewC.upgradeSchema();
+	 * // Use the newly enabled schema.
+	 * viewC.root = "test";
+	 *
+	 * synchronizeTrees();
+	 *
+	 * // View A is now incompatible with the stored schema:
+	 * assert.equal(viewA.compatibility.canView, false);
+	 *
+	 * // View B can still read the document, and now sees the string root which relies on the staged schema.
+	 * assert.deepEqual(viewB.root, "test");
+	 * ```
+	 * @privateRemarks
+	 * TODO:#44317 staged allowed types rely on schema validation of stored schema to output errors, these errors are not very
+	 * user friendly and should be improved, particularly in the case of staged allowed types
+	 *
+	 * TODO: the example above does not work tell in intellisense: its formatted to work onm the website. We should find a solution that works well for both.
+	 *
+	 * TODO: AB#45711: Update the docs above when recursive type support is added.
+	 */
+	staged: <const T extends LazyItem<TreeNodeSchema>>(
+		t: T | AnnotatedAllowedType<T>,
+	) => AnnotatedAllowedType<T>;
+}
+
+const schemaStaticsAlpha: SchemaStaticsAlpha = {
+	staged: <const T extends LazyItem<TreeNodeSchema>>(
+		t: T | AnnotatedAllowedType<T>,
+	): AnnotatedAllowedType<T> => {
+		const annotatedType = normalizeToAnnotatedAllowedType(t);
+		return {
+			type: annotatedType.type,
+			metadata: {
+				...annotatedType.metadata,
+				stagedSchemaUpgrade: createSchemaUpgrade(),
+			},
+		};
+	},
+};
+
 /**
  * {@link SchemaFactory} with additional alpha APIs.
  *
@@ -213,6 +376,16 @@ export class SchemaFactoryAlpha<
 	 */
 	public override readonly requiredRecursive = schemaStatics.requiredRecursive;
 
+	/**
+	 * {@inheritDoc SchemaStaticsAlpha.staged}
+	 */
+	public static staged = schemaStaticsAlpha.staged;
+
+	/**
+	 * {@inheritDoc SchemaStaticsAlpha.staged}
+	 */
+	public staged = schemaStaticsAlpha.staged;
+
 	/**
 	 * Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.
 	 *

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

@@ -13,31 +13,7 @@ import type {
 	InsertableTreeNodeFromImplicitAllowedTypes,
 } from "../core/index.js";
 import type { InsertableObjectFromSchemaRecord } from "../node-kinds/index.js";
-import {
-	type FieldKind,
-	type FieldProps,
-	createFieldSchema,
-	type ImplicitFieldSchema,
-} from "../fieldSchema.js";
-
-import type { FieldSchemaAlphaUnsafe, System_Unsafe } from "./typesUnsafe.js";
-
-export function createFieldSchemaUnsafe<
-	Kind extends FieldKind,
-	Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
-	TCustomMetadata = unknown,
->(
-	kind: Kind,
-	allowedTypes: Types,
-	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata> {
-	// At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe
-	return createFieldSchema(
-		kind,
-		allowedTypes as ImplicitAllowedTypes & Types,
-		props,
-	) as FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata>;
-}
+import type { ImplicitFieldSchema } from "../fieldSchema.js";
 
 /**
  * Compile time check for validity of a recursive schema.