@fluidframework/tree 2.50.0 → 2.51.0

package/dist/simple-tree/fieldSchema.d.ts

@@ -0,0 +1,423 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { ErasedType } from "@fluidframework/core-interfaces";
+import type { FieldKey } from "../core/index.js";
+import type { FlexTreeHydratedContextMinimal } from "../feature-libraries/index.js";
+import { type MakeNominal, type UnionToIntersection, type JsonCompatibleReadOnlyObject } from "../util/index.js";
+import type { TreeNodeSchema, TreeNode, UnhydratedFlexTreeNode, NormalizedAnnotatedAllowedTypes, ImplicitAllowedTypes, ImplicitAnnotatedAllowedTypes, UnannotateImplicitAllowedTypes, AllowedTypesMetadata, TreeNodeFromImplicitAllowedTypes, TreeLeafValue, InsertableTreeNodeFromImplicitAllowedTypes } from "./core/index.js";
+import type { SimpleFieldSchema } from "./simpleSchema.js";
+import type { UnsafeUnknownSchema } from "./unsafeUnknownSchema.js";
+import type { InsertableContent } from "./unhydratedFlexTreeFromInsertable.js";
+/**
+ * Kind of a field on an {@link TreeObjectNode}.
+ * @remarks
+ * More kinds may be added over time, so do not assume this is an exhaustive set.
+ * See {@link FieldSchema} for where these are used, and {@link SchemaFactory} for how to create schema which use them.
+ * @public
+ */
+export declare enum FieldKind {
+    /**
+     * A field which can be empty or filled.
+     * @remarks
+     * Allows 0 or one child.
+     */
+    Optional = 0,
+    /**
+     * A field which must always be filled.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Required = 1,
+    /**
+     * A special readonly field used for node identifier strings.
+     * @remarks
+     * Only allows exactly one child.
+     *
+     * See {@link SchemaFactory.identifier} for more details.
+     */
+    Identifier = 2
+}
+/**
+ * Maps from a property key to its corresponding {@link FieldProps.key | stored key} for the provided
+ * {@link ImplicitFieldSchema | field schema}.
+ *
+ * @remarks
+ * If an explicit stored key was specified in the schema, it will be used.
+ * Otherwise, the stored key is the same as the property key.
+ */
+export declare function getStoredKey(propertyKey: string, fieldSchema: ImplicitAnnotatedFieldSchema): FieldKey;
+/**
+ * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
+ * Otherwise, returns undefined.
+ */
+export declare function getExplicitStoredKey(fieldSchema: ImplicitAnnotatedFieldSchema): string | undefined;
+/**
+ * Additional information to provide to a {@link FieldSchema}.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+ * See {@link FieldSchemaMetadata.custom}.
+ *
+ * @public
+ */
+export interface FieldProps<TCustomMetadata = unknown> {
+    /**
+     * The unique identifier of a field, used in the persisted form of the tree.
+     *
+     * @remarks
+     * If not explicitly set via the schema, this is the same as the schema's property key.
+     *
+     * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.
+     * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,
+     * you can change the property key and specify the previous property key as the stored key.
+     *
+     * Notes:
+     *
+     * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`
+     * will always return the property keys specified in the schema, ignoring any stored keys that differ from
+     * the property keys.
+     *
+     * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys
+     * (accounting for those implicitly derived from property keys) contains no duplicates.
+     * This is validated at runtime.
+     *
+     * @example Refactoring code without breaking compatibility with existing data
+     *
+     * Consider some existing object schema:
+     *
+     * ```TypeScript
+     * class Point extends schemaFactory.object("Point", {
+     * 	xPosition: schemaFactory.number,
+     * 	yPosition: schemaFactory.number,
+     * 	zPosition: schemaFactory.optional(schemaFactory.number),
+     * });
+     * ```
+     *
+     * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.
+     *
+     * We would like to refactor the schema to omit "Position" from the property keys, but application data has
+     * already been persisted using the original property keys. To maintain compatibility with existing data,
+     * we can refactor the schema as follows:
+     *
+     * ```TypeScript
+     * class Point extends schemaFactory.object("Point", {
+     * 	x: schemaFactory.required(schemaFactory.number, { key: "xPosition" }),
+     * 	y: schemaFactory.required(schemaFactory.number, { key: "yPosition" }),
+     * 	z: schemaFactory.optional(schemaFactory.number, { key: "zPosition" }),
+     * });
+     * ```
+     *
+     * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.
+     *
+     * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.
+     */
+    readonly key?: string;
+    /**
+     * A default provider used for fields which were not provided any values.
+     * @privateRemarks
+     * We are using an erased type here, as we want to expose this API but `InsertableContent` and `NodeKeyManager` are not public.
+     */
+    readonly defaultProvider?: DefaultProvider;
+    /**
+     * Optional metadata to associate with the field.
+     *
+     * @remarks
+     * Note: this metadata is not persisted nor made part of the collaborative state; it is strictly client-local.
+     * Different clients in the same collaborative session may see different metadata for the same field.
+     */
+    readonly metadata?: FieldSchemaMetadata<TCustomMetadata>;
+}
+/**
+ * {@link FieldProps} extended with additional `alpha` options.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+ * See {@link FieldSchemaMetadata.custom}.
+ *
+ * @alpha @input
+ */
+export interface FieldPropsAlpha<TCustomMetadata = unknown> extends FieldProps<TCustomMetadata> {
+    /**
+     * The persisted metadata for this schema element.
+     */
+    readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}
+/**
+ * A {@link FieldProvider} which requires additional context in order to produce its content
+ */
+export type ContextualFieldProvider = (context: FlexTreeHydratedContextMinimal | "UseGlobalContext") => UnhydratedFlexTreeNode[];
+/**
+ * A {@link FieldProvider} which can produce its content in a vacuum.
+ */
+export type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];
+/**
+ * A function which produces content for a field every time that it is called.
+ */
+export type FieldProvider = ContextualFieldProvider | ConstantFieldProvider;
+/**
+ * Returns true if the given {@link FieldProvider} is a {@link ConstantFieldProvider}
+ */
+export declare function isConstant(fieldProvider: FieldProvider): fieldProvider is ConstantFieldProvider;
+/**
+ * Provides a default value for a field.
+ * @remarks
+ * If present in a `FieldSchema`, when constructing new tree content that field can be omitted, and a default will be provided.
+ * @system @sealed @public
+ */
+export interface DefaultProvider extends ErasedType<"@fluidframework/tree.FieldProvider"> {
+}
+export declare function extractFieldProvider(input: DefaultProvider): FieldProvider;
+export declare function getDefaultProvider(input: FieldProvider): DefaultProvider;
+/**
+ * Metadata associated with a {@link FieldSchema}.
+ *
+ * @remarks Specified via {@link FieldProps.metadata}.
+ *
+ * @sealed
+ * @public
+ */
+export interface FieldSchemaMetadata<TCustomMetadata = unknown> {
+    /**
+     * User-defined metadata.
+     */
+    readonly custom?: TCustomMetadata;
+    /**
+     * The description of the field.
+     *
+     * @remarks
+     *
+     * If provided, will be used by the system in scenarios where a description of the field is useful.
+     * E.g., when converting a field schema to {@link https://json-schema.org/ | JSON Schema}, this description will be
+     * used as the `description` field.
+     */
+    readonly description?: string | undefined;
+}
+/**
+ * Metadata associated with a {@link FieldSchema}. Includes fields used by alpha features.
+ *
+ * @remarks Specified via {@link FieldProps.metadata}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface FieldSchemaMetadataAlpha<TCustomMetadata = unknown> extends FieldSchemaMetadata<TCustomMetadata> {
+    /**
+     * The persisted metadata for this schema element.
+     */
+    readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}
+/**
+ * Package internal construction API.
+ */
+export declare function createFieldSchema<Kind extends FieldKind, Types extends ImplicitAllowedTypes, TCustomMetadata = unknown>(kind: Kind, annotatedTypes: Types, props?: FieldProps<TCustomMetadata>): FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
+/**
+ * Package internal construction API that supports annotations for allowed types.
+ */
+export declare function createFieldSchema<Kind extends FieldKind, Types extends ImplicitAnnotatedAllowedTypes, TCustomMetadata = unknown>(kind: Kind, annotatedTypes: Types, props?: FieldProps<TCustomMetadata>): FieldSchemaAlpha<Kind, UnannotateImplicitAllowedTypes<Types>, TCustomMetadata>;
+/**
+ * All policy for a specific field,
+ * including functionality that does not have to be kept consistent across versions or deterministic.
+ *
+ * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
+ * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link SchemaStatics.optional}.
+ * @privateRemarks
+ * Public access to the constructor is removed to prevent creating expressible but unsupported (or not stable) configurations.
+ * {@link createFieldSchema} can be used internally to create instances.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+ * See {@link FieldSchemaMetadata.custom}.
+ *
+ * @remarks
+ * All implementations of this are actually {@link FieldSchemaAlpha} which exposes some additional alpha APIs.
+ *
+ * @sealed @public
+ */
+export declare class FieldSchema<out Kind extends FieldKind = FieldKind, out Types extends ImplicitAllowedTypes = ImplicitAllowedTypes, out TCustomMetadata = unknown> {
+    /**
+     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
+     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     */
+    readonly kind: Kind;
+    /**
+     * What types of tree nodes are allowed in this field.
+     */
+    readonly allowedTypes: Types;
+    /**
+     * Optional properties associated with the field.
+     */
+    readonly props?: FieldProps<TCustomMetadata> | undefined;
+    /**
+     * This class is used with instanceof, and therefore should have nominal typing.
+     * This field enforces that.
+     */
+    protected _typeCheck: MakeNominal;
+    private readonly lazyTypes;
+    /**
+     * What types of tree nodes are allowed in this field.
+     * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.
+     */
+    get allowedTypeSet(): ReadonlySet<TreeNodeSchema>;
+    /**
+     * True if and only if, when constructing a node with this field, a value must be provided for it.
+     */
+    readonly requiresValue: boolean;
+    /**
+     * {@inheritDoc FieldProps.metadata}
+     */
+    get metadata(): FieldSchemaMetadata<TCustomMetadata>;
+    /**
+     * This class is `@sealed`: protected members like this constructor are for internal use only.
+     * Use {@link SchemaFactory} to create the FieldSchema instances.
+     */
+    protected constructor(
+    /**
+     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
+     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     */
+    kind: Kind, 
+    /**
+     * What types of tree nodes are allowed in this field.
+     */
+    allowedTypes: Types, 
+    /**
+     * Optional properties associated with the field.
+     */
+    props?: FieldProps<TCustomMetadata> | undefined);
+}
+/**
+ * {@link FieldSchema} including alpha APIs (currently {@link SimpleFieldSchema}).
+ * @remarks
+ * This class will go away once the alpha APIs are stable and implemented by {@link FieldSchema}.
+ * @sealed @alpha
+ */
+export declare class FieldSchemaAlpha<Kind extends FieldKind = FieldKind, Types extends ImplicitAllowedTypes = ImplicitAllowedTypes, TCustomMetadata = unknown> extends FieldSchema<Kind, Types, TCustomMetadata> implements SimpleFieldSchema {
+    readonly annotatedAllowedTypes: ImplicitAnnotatedAllowedTypes;
+    private readonly lazyIdentifiers;
+    private readonly lazyAnnotatedTypes;
+    private readonly propsAlpha;
+    /**
+     * Metadata on the types of tree nodes allowed on this field.
+     */
+    readonly allowedTypesMetadata: AllowedTypesMetadata;
+    /**
+     * Persisted metadata for this field schema.
+     */
+    get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined;
+    protected constructor(kind: Kind, types: Types, annotatedAllowedTypes: ImplicitAnnotatedAllowedTypes, props?: FieldPropsAlpha<TCustomMetadata>);
+    get allowedTypesIdentifiers(): ReadonlySet<string>;
+    /**
+     * What types of tree nodes are allowed in this field and their annotations.
+     * @remarks Counterpart to {@link FieldSchemaAlpha.annotatedAllowedTypes}, with any lazy definitions evaluated.
+     */
+    get annotatedAllowedTypesNormalized(): NormalizedAnnotatedAllowedTypes;
+}
+/**
+ * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitAnnotatedFieldSchema} to a {@link FieldSchema}.
+ */
+export declare function normalizeFieldSchema(schema: ImplicitFieldSchema | ImplicitAnnotatedFieldSchema): FieldSchemaAlpha;
+/**
+ * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.
+ * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:
+ * 1. They have the same {@link FieldKind | kinds}.
+ * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.
+ * 3. They have the same exact set of allowed types. The allowed types must be (respectively) reference equal.
+ *
+ * For example, comparing an ImplicitFieldSchema that is a {@link TreeNodeSchema} to an ImplicitFieldSchema that is a {@link FieldSchema}
+ * will return true if they are the same kind, the FieldSchema has exactly one allowed type (the TreeNodeSchema), and they have equivalent FieldProps.
+ */
+export declare function areImplicitFieldSchemaEqual(a: ImplicitFieldSchema, b: ImplicitFieldSchema): boolean;
+/**
+ * Returns true if the given {@link FieldSchema} are equivalent, otherwise false.
+ * @remarks Two FieldSchema are considered equivalent if all of the following are true:
+ * 1. They have the same {@link FieldKind | kinds}.
+ * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.
+ * 3. They have the same exact set of allowed types. The allowed types must be reference equal.
+ */
+export declare function areFieldSchemaEqual(a: FieldSchema, b: FieldSchema): boolean;
+/**
+ * Schema for a field of a tree node.
+ * @remarks
+ * Implicitly treats {@link ImplicitAllowedTypes} as a Required field of that type.
+ * @public
+ */
+export type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
+/**
+ * Annotated schema for a field of a tree node.
+ * @alpha
+ */
+export type ImplicitAnnotatedFieldSchema = FieldSchema | ImplicitAnnotatedAllowedTypes;
+/**
+ * Removes annotations from an annotated field schema.
+ * @system @alpha
+ */
+export type UnannotateImplicitFieldSchema<T extends ImplicitAnnotatedFieldSchema> = T extends ImplicitAnnotatedAllowedTypes ? UnannotateImplicitAllowedTypes<T> : T;
+/**
+ * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.
+ *
+ * @typeparam TSchema - When non-exact schema are provided this errors on the side of returning too general of a type (a conservative union of all possibilities).
+ * This is ideal for "output APIs" - i.e. it converts the schema type to the runtime type that a user will _read_ from the tree.
+ * Examples of such "non-exact" schema include `ImplicitFieldSchema`, `ImplicitAllowedTypes`, and  TypeScript unions of schema types.
+ * @public
+ */
+export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
+/**
+ * Type of content that can be inserted into the tree for a field of the given schema.
+ *
+ * @see {@link Input}
+ *
+ * @typeparam TSchemaInput - Schema to process.
+ * @typeparam TSchema - Do not specify: default value used as implementation detail.
+ * @public
+ */
+export type InsertableTreeFieldFromImplicitField<TSchemaInput extends ImplicitFieldSchema, TSchema = UnionToIntersection<TSchemaInput>> = [TSchema] extends [FieldSchema<infer Kind, infer Types>] ? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : [TSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
+/**
+ * Content which could be inserted into a field within a tree.
+ *
+ * @see {@link Input}
+ * @remarks
+ * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * @alpha
+ */
+export type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [
+    TSchema
+] extends [ImplicitFieldSchema] ? InsertableTreeFieldFromImplicitField<TSchema> : [TSchema] extends [UnsafeUnknownSchema] ? InsertableContent | undefined : never;
+/**
+ * Content which could be read from a field within a tree.
+ *
+ * @remarks
+ * Extended version of {@link TreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * Since reading from fields with non-exact schema is still safe, this is only useful (compared to {@link TreeFieldFromImplicitField}) when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}
+ * for use
+ * @system @alpha
+ */
+export type ReadableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = TreeFieldFromImplicitField<ReadSchema<TSchema>>;
+/**
+ * Adapter to remove {@link (UnsafeUnknownSchema:type)} from a schema type so it can be used with types for generating APIs for reading data.
+ *
+ * @remarks
+ * Since reading with non-exact schema is still safe, this is mainly useful when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}.
+ * @system @alpha
+ */
+export type ReadSchema<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [
+    TSchema
+] extends [ImplicitFieldSchema] ? TSchema : ImplicitFieldSchema;
+/**
+ * Suitable for output.
+ * For input must error on side of excluding undefined instead.
+ * @system @public
+ */
+export type ApplyKind<T, Kind extends FieldKind> = {
+    [FieldKind.Required]: T;
+    [FieldKind.Optional]: T | undefined;
+    [FieldKind.Identifier]: T;
+}[Kind];
+/**
+ * Suitable for input.
+ *
+ * @see {@link Input}
+ * @system @public
+ */
+export type ApplyKindInput<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = [
+    Kind
+] extends [FieldKind.Required] ? T : [Kind] extends [FieldKind.Optional] ? T | undefined : [Kind] extends [FieldKind.Identifier] ? DefaultsAreOptional extends true ? T | undefined : T : never;
+//# sourceMappingURL=fieldSchema.d.ts.map

package/dist/simple-tree/fieldSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/fieldSchema.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/{schemaTypes.js → fieldSchema.js}

@@ -4,29 +4,11 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsafeUnknownSchema = exports.markSchemaMostDerived = exports.evaluateLazySchema = exports.areFieldSchemaEqual = exports.areImplicitFieldSchemaEqual = exports.unannotateSchemaRecord = exports.unannotateImplicitAllowedTypes = exports.normalizeAnnotatedAllowedTypes = exports.normalizeToAnnotatedAllowedType = exports.normalizeAllowedTypes = exports.normalizeFieldSchema = exports.ObjectFieldSchema = exports.FieldSchemaAlpha = exports.FieldSchema = exports.createFieldSchema = exports.getDefaultProvider = exports.extractFieldProvider = exports.isConstant = exports.getExplicitStoredKey = exports.getStoredKey = exports.FieldKind = exports.isAnnotatedAllowedType = exports.isTreeNodeSchemaClass = void 0;
+exports.areFieldSchemaEqual = exports.areImplicitFieldSchemaEqual = exports.normalizeFieldSchema = exports.FieldSchemaAlpha = exports.FieldSchema = exports.createFieldSchema = exports.getDefaultProvider = exports.extractFieldProvider = exports.isConstant = exports.getExplicitStoredKey = exports.getStoredKey = exports.FieldKind = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../util/index.js");
 const index_js_2 = require("./core/index.js");
-const flexList_js_1 = require("./flexList.js");
-const leafNodeSchema_js_1 = require("./leafNodeSchema.js");
-const treeNodeValid_js_1 = require("./treeNodeValid.js");
-/**
- * Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.
- * @internal
- */
-function isTreeNodeSchemaClass(schema) {
-    return schema.constructor !== undefined;
-}
-exports.isTreeNodeSchemaClass = isTreeNodeSchemaClass;
-/**
- * Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.
- */
-function isAnnotatedAllowedType(allowedType) {
-    return "metadata" in allowedType && "type" in allowedType;
-}
-exports.isAnnotatedAllowedType = isAnnotatedAllowedType;
 /**
  * Kind of a field on an {@link TreeObjectNode}.
  * @remarks
@@ -156,7 +138,7 @@ class FieldSchema {
         if (!(this instanceof FieldSchemaAlpha)) {
             throw new internal_2.UsageError("FieldSchema is @sealed: sub-classing is not allowed.");
         }
-        this.lazyTypes = new internal_1.Lazy(() => normalizeAllowedTypes(this.allowedTypes));
+        this.lazyTypes = new internal_1.Lazy(() => (0, index_js_2.normalizeAllowedTypes)(this.allowedTypes));
         // TODO: optional fields should (by default) get a default provider that returns undefined, removing the need to special case them here:
         this.requiresValue =
             this.props?.defaultProvider === undefined && this.kind !== FieldKind.Optional;
@@ -182,7 +164,7 @@ class FieldSchemaAlpha extends FieldSchema {
         this.allowedTypesMetadata = (0, index_js_2.isAnnotatedAllowedTypes)(annotatedAllowedTypes)
             ? annotatedAllowedTypes.metadata
             : {};
-        this.lazyAnnotatedTypes = new internal_1.Lazy(() => normalizeAnnotatedAllowedTypes(annotatedAllowedTypes));
+        this.lazyAnnotatedTypes = new internal_1.Lazy(() => (0, index_js_2.normalizeAnnotatedAllowedTypes)(annotatedAllowedTypes));
         this.lazyIdentifiers = new internal_1.Lazy(() => new Set([...this.allowedTypeSet].map((t) => t.identifier)));
         this.propsAlpha = props;
     }
@@ -199,18 +181,8 @@ class FieldSchemaAlpha extends FieldSchema {
 }
 exports.FieldSchemaAlpha = FieldSchemaAlpha;
 (() => {
-    createFieldSchemaPrivate = (kind, annotatedAllowedTypes, props) => new FieldSchemaAlpha(kind, unannotateImplicitAllowedTypes(annotatedAllowedTypes), annotatedAllowedTypes, props);
+    createFieldSchemaPrivate = (kind, annotatedAllowedTypes, props) => new FieldSchemaAlpha(kind, (0, index_js_2.unannotateImplicitAllowedTypes)(annotatedAllowedTypes), annotatedAllowedTypes, props);
 })();
-/**
- * {@link FieldSchemaAlpha} including {@link SimpleObjectFieldSchema}.
- */
-class ObjectFieldSchema extends FieldSchemaAlpha {
-    constructor(kind, allowedTypes, annotatedTypes, props) {
-        super(kind, allowedTypes, annotatedTypes, props);
-        this.storedKey = props.key;
-    }
-}
-exports.ObjectFieldSchema = ObjectFieldSchema;
 /**
  * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitAnnotatedFieldSchema} to a {@link FieldSchema}.
  */
@@ -220,108 +192,6 @@ function normalizeFieldSchema(schema) {
         : createFieldSchema(FieldKind.Required, schema);
 }
 exports.normalizeFieldSchema = normalizeFieldSchema;
-/**
- * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any
- * lazy schema declarations.
- *
- * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
- * recursive schemas may fail.
- *
- * @internal
- */
-function normalizeAllowedTypes(types) {
-    const normalized = new Set();
-    if ((0, index_js_1.isReadonlyArray)(types)) {
-        // Types array must not be modified after it is normalized since that would result in the user of the normalized data having wrong (out of date) content.
-        Object.freeze(types);
-        for (const lazyType of types) {
-            normalized.add(evaluateLazySchema(lazyType));
-        }
-    }
-    else {
-        normalized.add(evaluateLazySchema(types));
-    }
-    return normalized;
-}
-exports.normalizeAllowedTypes = normalizeAllowedTypes;
-/**
- * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
- */
-function normalizeToAnnotatedAllowedType(type) {
-    return isAnnotatedAllowedType(type)
-        ? type
-        : {
-            metadata: {},
-            type,
-        };
-}
-exports.normalizeToAnnotatedAllowedType = normalizeToAnnotatedAllowedType;
-/**
- * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, by eagerly evaluating any
- * lazy schema declarations and adding empty metadata if it doesn't already exist.
- *
- * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
- * recursive schemas may fail.
- */
-function normalizeAnnotatedAllowedTypes(types) {
-    const typesWithoutAnnotation = (0, index_js_2.isAnnotatedAllowedTypes)(types) ? types.types : types;
-    const annotatedTypes = [];
-    if ((0, index_js_1.isReadonlyArray)(typesWithoutAnnotation)) {
-        for (const annotatedType of typesWithoutAnnotation) {
-            if (isAnnotatedAllowedType(annotatedType)) {
-                annotatedTypes.push({
-                    type: evaluateLazySchema(annotatedType.type),
-                    metadata: annotatedType.metadata,
-                });
-            }
-            else {
-                annotatedTypes.push({ type: evaluateLazySchema(annotatedType), metadata: {} });
-            }
-        }
-    }
-    else {
-        if (isAnnotatedAllowedType(typesWithoutAnnotation)) {
-            annotatedTypes.push({
-                type: evaluateLazySchema(typesWithoutAnnotation.type),
-                metadata: typesWithoutAnnotation.metadata,
-            });
-        }
-        else {
-            annotatedTypes.push({ type: evaluateLazySchema(typesWithoutAnnotation), metadata: {} });
-        }
-    }
-    return {
-        metadata: (0, index_js_2.isAnnotatedAllowedTypes)(types) ? types.metadata : {},
-        types: annotatedTypes,
-    };
-}
-exports.normalizeAnnotatedAllowedTypes = normalizeAnnotatedAllowedTypes;
-/**
- * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing
- * any annotations.
- * @remarks
- * This does not evaluate any lazy schemas.
- */
-function unannotateImplicitAllowedTypes(types) {
-    return ((0, index_js_2.isAnnotatedAllowedTypes)(types)
-        ? types.types.map((allowedType) => isAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType)
-        : (0, index_js_1.isReadonlyArray)(types)
-            ? types.map((allowedType) => isAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType)
-            : isAnnotatedAllowedType(types)
-                ? types.type
-                : types);
-}
-exports.unannotateImplicitAllowedTypes = unannotateImplicitAllowedTypes;
-/**
- * Removes annotations from a schema record.
- */
-function unannotateSchemaRecord(schemaRecord) {
-    return Object.fromEntries(Object.entries(schemaRecord).map(([key, schema]) => [
-        key,
-        schema instanceof FieldSchema ? schema : unannotateImplicitAllowedTypes(schema),
-    ]));
-}
-exports.unannotateSchemaRecord = unannotateSchemaRecord;
 /**
  * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.
  * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:
@@ -402,64 +272,4 @@ function arePersistedMetadataEqual(a, b) {
     const bStringified = JSON.stringify(b);
     return aStringified === bStringified;
 }
-const cachedLazyItem = new WeakMap();
-/**
- * Returns the schema referenced by the {@link LazyItem}.
- * @remarks
- * Caches results to handle {@link LazyItem}s which compute their resulting schema.
- * @alpha
- */
-function evaluateLazySchema(value) {
-    const evaluatedSchema = (0, flexList_js_1.isLazy)(value)
-        ? (0, index_js_1.getOrCreate)(cachedLazyItem, value, value)
-        : value;
-    if (evaluatedSchema === undefined) {
-        throw new internal_2.UsageError(`Encountered an undefined schema. This could indicate that some referenced schema has not yet been instantiated.`);
-    }
-    markSchemaMostDerived(evaluatedSchema);
-    return evaluatedSchema;
-}
-exports.evaluateLazySchema = evaluateLazySchema;
-/**
- * Indicates that the provided schema is the "most derived" version in its class hierarchy.
- *
- * @param oneTimeInitialize - If true this runs {@link TreeNodeValid.oneTimeInitialize} which does even more initialization and validation.
- * `oneTimeInitialize` can't safely be run until all transitively referenced schema are defined, so which cases can safely use it are more limited.
- * When legal for the caller to set this to true, it is preferred, but it is often not safe due to possible forward references.
- * @remarks
- * See {@link MostDerivedData} and {@link SchemaFactory} for details on what a "most derived" schema is and why it matters.
- *
- * This is a helper for invoking {@link TreeNodeValid.markMostDerived} for {@link TreeNodeSchema}.
- *
- * Calling this helps with error messages about invalid schema usage (See {@link SchemaFactory} for the rules, some of which this helps validate).
- * Typically this should be called for each schema as early as practical to improve error reporting for invalid usages of schema
- * (using two different schema derived from the same {@link SchemaFactory} produced base class).
- *
- * Note that construction of actual {@link TreeNode} instances or use of a schema transitively in a {@link TreeViewConfiguration} already do this,
- * so any calls to this that is unconditionally after that point for the given schema is not needed.
- * Instead most usages of this should be from those cases, and from miscellaneous cases where a schema is passed into an public API where theoretically someone could accidentally
- * pass in a base class of a schema instead of the most derived one.
- */
-function markSchemaMostDerived(schema, oneTimeInitialize = false) {
-    if (schema instanceof leafNodeSchema_js_1.LeafNodeSchema) {
-        return;
-    }
-    if (!(0, index_js_2.inPrototypeChain)(schema, treeNodeValid_js_1.TreeNodeValid)) {
-        // Use JSON.stringify to quote and escape identifier string.
-        throw new internal_2.UsageError(`Schema for ${JSON.stringify(schema.identifier)} does not extend a SchemaFactory generated class. This is invalid.`);
-    }
-    const schemaValid = schema;
-    if (oneTimeInitialize) {
-        schemaValid.oneTimeInitialize();
-    }
-    else {
-        schemaValid.markMostDerived();
-    }
-}
-exports.markSchemaMostDerived = markSchemaMostDerived;
-/**
- * {@inheritdoc (UnsafeUnknownSchema:type)}
- * @alpha
- */
-exports.UnsafeUnknownSchema = Symbol("UnsafeUnknownSchema");
-//# sourceMappingURL=schemaTypes.js.map
+//# sourceMappingURL=fieldSchema.js.map