@fluidframework/tree 2.63.0-359461 → 2.63.0-359734

package/dist/simple-tree/core/allowedTypes.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import { type ErasedBaseType, ErasedTypeImplementation } from "@fluidframework/core-interfaces/internal";
 import { type IsUnion, type MakeNominal } from "../../util/index.js";
 import { type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { type InsertableTypedNode, type NodeFromSchema, type TreeNodeSchema } from "./treeNodeSchema.js";
@@ -24,8 +25,10 @@ import { type InsertableTypedNode, type NodeFromSchema, type TreeNodeSchema } fr
  * but some of the items are known to be present unconditionally.
  * For example, typing `[typeof A] | [typeof A, typeof B]` as `[typeof A, typeof B | typeof A]` is allowed,
  * and can produce more useful {@link Input} types.
- * @privateRemarks
- * Code reading data from this should use `normalizeAllowedTypes` to ensure consistent handling, caching, nice errors etc.
+ *
+ * Due to one implementation of this being {@link AllowedTypesFull}, it is not safe to assume this is an array (as determined by `Array.isArray`).
+ *
+ * Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.
  * @system @public
  */
 export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
@@ -33,6 +36,9 @@ export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
  * Stores annotations for an individual allowed type.
  * @remarks
  * Create using APIs on {@link SchemaFactoryAlpha}, like {@link SchemaStaticsAlpha.staged}.
+ * @privateRemarks
+ * Since this is sealed, users are not supposed to create instances of it directly.
+ * Making it extend ErasedType could enforce that.
  * @alpha
  * @sealed
  */
@@ -47,22 +53,21 @@ export interface AnnotatedAllowedType<T = LazyItem<TreeNodeSchema>> {
     readonly type: T;
 }
 /**
- * {@link AnnotatedAllowedTypes} but with the lazy schema references eagerly evaluated.
+ * {@link AllowedTypesFull} but with the lazy schema references eagerly evaluated.
  * @sealed
  * @alpha
  */
-export interface NormalizedAnnotatedAllowedTypes extends AnnotatedAllowedTypes<TreeNodeSchema> {
-}
+export type AllowedTypesFullEvaluated = AllowedTypesFull<readonly AnnotatedAllowedType<TreeNodeSchema>[]>;
 /**
  * Checks if the input is an {@link AnnotatedAllowedTypes}.
  */
-export declare function isAnnotatedAllowedTypes(allowedTypes: ImplicitAnnotatedAllowedTypes): allowedTypes is AnnotatedAllowedTypes;
+export declare function isAnnotatedAllowedTypes(allowedTypes: ImplicitAllowedTypes): allowedTypes is AllowedTypesFullInternal;
 /**
  * Stores annotations for a set of allowed types.
  * @alpha
  * @sealed
  */
-export interface AnnotatedAllowedTypes<T = LazyItem<TreeNodeSchema>> {
+export interface AnnotatedAllowedTypes<T = readonly AnnotatedAllowedType[]> extends ErasedBaseType<"tree.AnnotatedAllowedTypes"> {
     /**
      * Annotations that apply to a set of allowed types.
      */
@@ -70,7 +75,79 @@ export interface AnnotatedAllowedTypes<T = LazyItem<TreeNodeSchema>> {
     /**
      * All the allowed types that the annotations apply to. The types themselves may also have individual annotations.
      */
-    readonly types: readonly AnnotatedAllowedType<T>[];
+    readonly types: T;
+    /**
+     * Get this {@link AnnotatedAllowedTypes} but with any lazy schema references eagerly evaluated.
+     * @remarks
+     * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.
+     */
+    evaluate(): AllowedTypesFullEvaluated;
+    /**
+     * Get the allowed types as a set with any lazy schema references eagerly evaluated.
+     * @remarks
+     * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.
+     */
+    evaluateSet(): ReadonlySet<TreeNodeSchema>;
+    /**
+     * Get the allowed types as a set of identifiers with any lazy schema references eagerly evaluated.
+     * @remarks
+     * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.
+     *
+     * It is recommend to work in terms of {@link TreeNodeSchema}
+     * rather than identifiers where possible since its more type safe and it is possible that two schema with the same identifier exist.
+     */
+    evaluateIdentifiers(): ReadonlySet<string>;
+}
+/**
+ * Stores annotations for a set of allowed types.
+ * @remarks
+ * Most expressive form of AllowedTypes which any of the implicit types can be normalized to.
+ * @alpha
+ * @sealed
+ */
+export type AllowedTypesFull<T extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[]> = AnnotatedAllowedTypes<T> & UnannotateAllowedTypesList<T>;
+/**
+ * Creates an {@link AllowedTypesFull} type from a mixed array of annotated and unannotated allowed types.
+ * @alpha
+ * @sealed
+ */
+export type AllowedTypesFullFromMixed<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = UnannotateAllowedTypesList<T> & AnnotatedAllowedTypes<AnnotateAllowedTypesList<T>>;
+/**
+ * The same as the built-in InstanceType, but works on classes with private constructors.
+ * @privateRemarks
+ * This is based on the trick in {@link https://stackoverflow.com/a/74657881}.
+ */
+type InstanceTypeRelaxed<TClass> = InstanceType<(new () => never) & TClass>;
+/**
+ * {@link AllowedTypesFull} but with internal types.
+ */
+export type AllowedTypesFullInternal<T extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[]> = AnnotatedAllowedTypesInternal<T> & UnannotateAllowedTypesList<T>;
+type AllowedTypesFullInternalEvaluated = AllowedTypesFullInternal<readonly AnnotatedAllowedType<TreeNodeSchema>[]>;
+/**
+ * The implementation of {@link AnnotatedAllowedTypes}. Also implements {@link AllowedTypesFull}.
+ * @remarks
+ * Due to TypeScript limitations, this class cannot directly state it implements {@link AllowedTypesFull}.
+ * As a workaround for that, the static `create` method returns the intersection type.
+ */
+export declare class AnnotatedAllowedTypesInternal<T extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[]> extends ErasedTypeImplementation<AnnotatedAllowedTypes<T>> implements AnnotatedAllowedTypes<T> {
+    readonly types: T;
+    readonly metadata: AllowedTypesMetadata;
+    readonly unannotatedTypes: UnannotateAllowedTypesList<T>;
+    /**
+     * True if and only if there is at least one lazy schema reference in the types arrays.
+     */
+    private readonly isLazy;
+    private readonly lazyEvaluate;
+    private constructor();
+    evaluate(): AllowedTypesFullInternalEvaluated;
+    evaluateSet(): ReadonlySet<TreeNodeSchema>;
+    evaluateIdentifiers(): ReadonlySet<string>;
+    static [Symbol.hasInstance]<TThis extends (abstract new (...args: unknown[]) => object) | typeof AnnotatedAllowedTypesInternal>(this: TThis, value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes): value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull;
+    static narrow<TThis extends (abstract new (...args: unknown[]) => object) | typeof AnnotatedAllowedTypesInternal>(this: TThis, value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes): asserts value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull;
+    private static proxy;
+    static create<const T extends readonly AnnotatedAllowedType[]>(types: T, metadata?: AllowedTypesMetadata): AnnotatedAllowedTypesInternal<T> & AllowedTypesFull<T>;
+    static createUnannotated<const T extends AllowedTypes>(types: T, metadata?: AllowedTypesMetadata): AnnotatedAllowedTypesInternal & T;
+    static createMixed<const T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]>(types: T, metadata?: AllowedTypesMetadata): AllowedTypesFullFromMixed<T>;
 }
 /**
  * Annotations that apply to a set of allowed types.
@@ -140,6 +217,8 @@ export declare class SchemaUpgrade {
  * When referring to types that are declared after the definition of the `ImplicitAllowedTypes`, the schema can be wrapped in a lambda to allow the forward reference.
  * See {@link ValidateRecursiveSchema} for details on how to structure the `ImplicitAllowedTypes` instances when constructing recursive schema.
  *
+ * Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.
+ *
  * @example Explicit use with strong typing
  * ```typescript
  * const sf = new SchemaFactory("myScope");
@@ -153,80 +232,44 @@ export declare class SchemaUpgrade {
  * class A extends sf.array("example", [() => B]) {}
  * class B extends sf.array("Inner", sf.number) {}
  * ```
- * @privateRemarks
- * Code reading data from this should use `normalizeAllowedTypes` to ensure consistent handling, caching, nice errors etc.
  * @public
  */
 export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
-/**
- * Types of {@link TreeNode|TreeNodes} or {@link TreeLeafValue|TreeLeafValues} allowed at a location in a tree with
- * additional metadata associated with the location they're allowed at.
- * @alpha
- * @input
- */
-export type ImplicitAnnotatedAllowedTypes = TreeNodeSchema | AnnotatedAllowedType | AnnotatedAllowedTypes | readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];
-/**
- * Returns an {@link ImplicitAllowedTypes} that is equivalent to the input without annotations.
- * @system @alpha
- */
-export type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> = T extends AnnotatedAllowedTypes ? UnannotateAllowedTypes<T> : T extends AnnotatedAllowedType ? UnannotateAllowedTypesList<[T]> : T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[] ? UnannotateAllowedTypesList<T> : T extends TreeNodeSchema ? T : ImplicitAllowedTypes;
 /**
  * Removes annotations from a list of allowed types that may contain annotations.
  * @system @alpha
  */
 export type UnannotateAllowedTypesList<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = {
-    [I in keyof T]: UnannotateAllowedType<T[I]>;
+    [I in keyof T]: T[I] extends AnnotatedAllowedType<infer X> ? X : T[I];
 };
 /**
- * Removes all annotations from a set of allowed types.
- * @system @alpha
- */
-export type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> = UnannotateAllowedTypesList<T["types"]>;
-/**
- * Removes annotations from an allowed type.
- * @remarks
- * If the input could be lazy
- * (is a LazyItem or AnnotatedAllowedType<LazyItem> instead of just a TreeNodeSchema | AnnotatedAllowedType<TreeNodeSchema>)
- * then the output of this will be a LazyItem and thus is not valid as an ImplicitAllowedTypes without wrapping it in an array.
- * This can however be used on items within an AllowedTypes array.
+ * Add annotations to a list of allowed types that may or may not contain annotations.
  * @system @alpha
  */
-export type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? X : T;
+export type AnnotateAllowedTypesList<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = {
+    [I in keyof T]: T[I] extends AnnotatedAllowedType<unknown> ? T[I] : AnnotatedAllowedType<T[I]>;
+};
 /**
- * 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
+ * Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFull}.
+ * @alpha
  */
-export declare function normalizeAllowedTypes(types: ImplicitAnnotatedAllowedTypes): ReadonlySet<TreeNodeSchema>;
+export declare function normalizeAllowedTypes(types: ImplicitAllowedTypes): AllowedTypesFull;
 /**
  * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
  */
 export declare function normalizeToAnnotatedAllowedType<T extends LazyItem<TreeNodeSchema>>(type: T | AnnotatedAllowedType<T>): AnnotatedAllowedType<T>;
 /**
- * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, by eagerly evaluating any
+ * Normalizes allowed types to an {@link AllowedTypesFullInternal}.
+ */
+export declare function normalizeAllowedTypesInternal(type: ImplicitAllowedTypes): AllowedTypesFullInternal;
+/**
+ * Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFullInternalEvaluated} 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.
  */
-export declare function normalizeAnnotatedAllowedTypes(types: ImplicitAnnotatedAllowedTypes): NormalizedAnnotatedAllowedTypes;
-/**
- * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing
- * any annotations.
- * @remarks
- * This does not evaluate any lazy schemas.
- */
-export declare function unannotateImplicitAllowedTypes<Types extends ImplicitAnnotatedAllowedTypes>(types: Types): UnannotateImplicitAllowedTypes<Types>;
-/**
- * Converts an {@link AnnotatedAllowedType} to an {@link LazyItem} by removing any annotations.
- * @remarks
- * This does not evaluate any lazy schemas.
- */
-export declare function unannotateAllowedType<Type extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>>(allowedType: Type): UnannotateAllowedType<Type>;
+export declare function normalizeAndEvaluateAnnotatedAllowedTypes(types: ImplicitAllowedTypes): AllowedTypesFullInternalEvaluated;
 /**
  * Returns the schema referenced by the {@link LazyItem}.
  * @remarks
@@ -237,7 +280,7 @@ export declare function evaluateLazySchema<T extends TreeNodeSchema>(value: Lazy
 /**
  * Throws a UsageError if the provided schema is undefined, most likely due to being used before it was initialized.
  */
-export declare function checkForUninitializedSchema(schema: ImplicitAnnotatedAllowedTypes | LazyItem<TreeNodeSchema> | AnnotatedAllowedType): void;
+export declare function checkForUninitializedSchema(schema: ImplicitAllowedTypes | LazyItem<TreeNodeSchema> | AnnotatedAllowedType): void;
 /**
  * Indicates that the provided schema is the "most derived" version in its class hierarchy.
  *
@@ -339,10 +382,25 @@ export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitA
  * @typeparam TList - AllowedTypes to process
  *
  * @privateRemarks
- * This loop is manually unrolled to allow larger unions before hitting the recursion limit in TypeScript.
+ * This loop is non-recursive to allow larger unions before hitting the recursion limit in TypeScript.
  * @system @public
  */
 export type InsertableTreeNodeFromAllowedTypes<TList extends AllowedTypes> = IsUnion<TList> extends true ? never : {
-    readonly [Property in keyof TList]: TList[Property] extends LazyItem<infer TSchema extends TreeNodeSchema> ? InsertableTypedNode<TSchema> : never;
-}[number];
+    readonly [Property in keyof TList]: [TList[Property]] extends [
+        LazyItem<infer TSchema extends TreeNodeSchema>
+    ] ? InsertableTypedNode<TSchema> : never;
+}[NumberKeys<TList>];
+/**
+ * Extracts the keys of `T` which are numbers.
+ * @remarks
+ * The keys are extracted as strings which can be used to index `T`.
+ *
+ * This handles cases like `{ x: 4 } & [5, 6]` returning `"0"` and `"1"`.
+ * Such cases are difficult to handle since `keyof` includes `number` in such cases, but the type can not be indexed by `number`.
+ * @system @public
+ */
+export type NumberKeys<T, Transformed = {
+    readonly [Property in keyof T as number extends Property ? never : Property]: Property;
+}> = Transformed[`${number}` & keyof Transformed];
+export {};
 //# sourceMappingURL=allowedTypes.d.ts.map

package/dist/simple-tree/core/allowedTypes.d.ts.map

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

package/dist/simple-tree/core/allowedTypes.js

@@ -4,8 +4,10 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.markSchemaMostDerived = exports.checkForUninitializedSchema = exports.evaluateLazySchema = exports.unannotateAllowedType = exports.unannotateImplicitAllowedTypes = exports.normalizeAnnotatedAllowedTypes = exports.normalizeToAnnotatedAllowedType = exports.normalizeAllowedTypes = exports.SchemaUpgrade = exports.createSchemaUpgrade = exports.isAnnotatedAllowedType = exports.isAnnotatedAllowedTypes = void 0;
+exports.markSchemaMostDerived = exports.checkForUninitializedSchema = exports.evaluateLazySchema = exports.normalizeAndEvaluateAnnotatedAllowedTypes = exports.normalizeAllowedTypesInternal = exports.normalizeToAnnotatedAllowedType = exports.normalizeAllowedTypes = exports.SchemaUpgrade = exports.createSchemaUpgrade = exports.isAnnotatedAllowedType = exports.AnnotatedAllowedTypesInternal = exports.isAnnotatedAllowedTypes = void 0;
 const internal_1 = require("@fluidframework/telemetry-utils/internal");
+const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_3 = require("@fluidframework/core-interfaces/internal");
 const index_js_1 = require("../../util/index.js");
 const flexList_js_1 = require("./flexList.js");
 const treeNodeSchema_js_1 = require("./treeNodeSchema.js");
@@ -15,11 +17,135 @@ const treeNodeValid_js_1 = require("./treeNodeValid.js");
  */
 function isAnnotatedAllowedTypes(allowedTypes) {
     checkForUninitializedSchema(allowedTypes);
-    return (
-    // Class based schema, and lazy schema references report type "function": filtering them out with typeof makes narrowing based on members mostly safe
-    typeof allowedTypes === "object" && "metadata" in allowedTypes && "types" in allowedTypes);
+    return allowedTypes instanceof AnnotatedAllowedTypesInternal;
 }
 exports.isAnnotatedAllowedTypes = isAnnotatedAllowedTypes;
+/**
+ * The implementation of {@link AnnotatedAllowedTypes}. Also implements {@link AllowedTypesFull}.
+ * @remarks
+ * Due to TypeScript limitations, this class cannot directly state it implements {@link AllowedTypesFull}.
+ * As a workaround for that, the static `create` method returns the intersection type.
+ */
+class AnnotatedAllowedTypesInternal extends internal_3.ErasedTypeImplementation {
+    constructor(types, metadata = {}) {
+        super();
+        this.types = types;
+        this.metadata = metadata;
+        this.unannotatedTypes = types.map((type) => type.type);
+        // Since the array has been copied, mutations to it will not be handled correctly so freeze it.
+        // Support for such mutations could be added at a later date by making more things lazy.
+        Object.freeze(this.types);
+        Object.freeze(this.unannotatedTypes);
+        this.isLazy = false;
+        for (const type of this.unannotatedTypes) {
+            if ((0, flexList_js_1.isLazy)(type)) {
+                this.isLazy = true;
+            }
+            else {
+                markSchemaMostDerived(type);
+            }
+        }
+        const proxy = AnnotatedAllowedTypesInternal.proxy(this);
+        this.lazyEvaluate = new internal_2.Lazy(() => {
+            const annotated = this.isLazy
+                ? AnnotatedAllowedTypesInternal.create(this.types.map((type) => ({
+                    ...type,
+                    type: evaluateLazySchema(type.type),
+                })), this.metadata)
+                : proxy;
+            return {
+                annotated,
+                set: new Set(annotated.unannotatedTypes),
+                identifiers: new Set(annotated.unannotatedTypes.map((t) => t.identifier)),
+            };
+        });
+        return proxy;
+    }
+    evaluate() {
+        return this.lazyEvaluate.value.annotated;
+    }
+    evaluateSet() {
+        return this.lazyEvaluate.value.set;
+    }
+    evaluateIdentifiers() {
+        return this.lazyEvaluate.value.identifiers;
+    }
+    static [Symbol.hasInstance](value) {
+        return Object.prototype.isPrototypeOf.call(this.prototype, value);
+    }
+    static narrow(value) {
+        if (!Object.prototype.isPrototypeOf.call(this.prototype, value)) {
+            throw new TypeError("Invalid AnnotatedAllowedTypes instance");
+        }
+    }
+    static proxy(result) {
+        const proxy = new Proxy(result, {
+            set: () => {
+                throw new internal_1.UsageError("AnnotatedAllowedTypes is immutable");
+            },
+            get: (target, property, receiver) => {
+                // Hide common array editing methods.
+                if (property === "push" || property === "pop") {
+                    return undefined;
+                }
+                // Forward array lookup and array methods to the unannotated types array.
+                if (property in target.unannotatedTypes) {
+                    return Reflect.get(target.unannotatedTypes, property);
+                }
+                // Forward anything else to target.
+                return Reflect.get(target, property);
+            },
+            has: (target, property) => {
+                if (property in target.unannotatedTypes) {
+                    return true;
+                }
+                // Forward anything else to target.
+                return property in target;
+            },
+            ownKeys: (target) => {
+                const targetKeys = Reflect.ownKeys(target);
+                const unannotatedTypesKeys = Reflect.ownKeys(target.unannotatedTypes);
+                return [...unannotatedTypesKeys, ...targetKeys];
+            },
+            getOwnPropertyDescriptor: (target, property) => {
+                if (Object.prototype.hasOwnProperty.call(target.unannotatedTypes, property)) {
+                    const inner = Object.getOwnPropertyDescriptor(target.unannotatedTypes, property);
+                    return {
+                        ...inner,
+                        // Since these properties are not on the target, make them non-configurable to confirm with proxy invariants.
+                        configurable: true,
+                        writable: false,
+                    };
+                }
+                else {
+                    const inner = Object.getOwnPropertyDescriptor(target, property);
+                    return {
+                        ...inner,
+                        writable: false,
+                        // Allow only array entries to be enumerable.
+                        enumerable: false,
+                    };
+                }
+            },
+        });
+        return proxy;
+    }
+    static create(types, metadata = {}) {
+        const result = new AnnotatedAllowedTypesInternal(types, metadata);
+        return result;
+    }
+    static createUnannotated(types, metadata = {}) {
+        const annotatedTypes = types.map(normalizeToAnnotatedAllowedType);
+        const result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);
+        return result;
+    }
+    static createMixed(types, metadata = {}) {
+        const annotatedTypes = types.map(normalizeToAnnotatedAllowedType);
+        const result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);
+        return result;
+    }
+}
+exports.AnnotatedAllowedTypesInternal = AnnotatedAllowedTypesInternal;
 /**
  * Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.
  */
@@ -47,29 +173,11 @@ exports.SchemaUpgrade = SchemaUpgrade;
     exports.createSchemaUpgrade = () => new SchemaUpgrade();
 })();
 /**
- * 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
+ * Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFull}.
+ * @alpha
  */
 function normalizeAllowedTypes(types) {
-    // remove annotations before normalizing
-    const unannotated = unannotateImplicitAllowedTypes(types);
-    const normalized = new Set();
-    if ((0, index_js_1.isReadonlyArray)(unannotated)) {
-        // 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(unannotated);
-        for (const lazyType of unannotated) {
-            normalized.add(evaluateLazySchema(lazyType));
-        }
-    }
-    else {
-        normalized.add(evaluateLazySchema(unannotated));
-    }
-    return normalized;
+    return normalizeAllowedTypesInternal(types);
 }
 exports.normalizeAllowedTypes = normalizeAllowedTypes;
 /**
@@ -85,72 +193,42 @@ function normalizeToAnnotatedAllowedType(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.
+ * See note inside {@link normalizeAllowedTypesInternal}.
  */
-function normalizeAnnotatedAllowedTypes(types) {
-    const typesWithoutAnnotation = 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: isAnnotatedAllowedTypes(types) ? types.metadata : {},
-        types: annotatedTypes,
-    };
-}
-exports.normalizeAnnotatedAllowedTypes = normalizeAnnotatedAllowedTypes;
+const cachedNormalize = new WeakMap();
 /**
- * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing
- * any annotations.
- * @remarks
- * This does not evaluate any lazy schemas.
+ * Normalizes allowed types to an {@link AllowedTypesFullInternal}.
  */
-function unannotateImplicitAllowedTypes(types) {
-    return (isAnnotatedAllowedTypes(types)
-        ? types.types.map(unannotateAllowedType)
-        : (0, index_js_1.isReadonlyArray)(types)
-            ? types.map(unannotateAllowedType)
-            : isAnnotatedAllowedType(types)
-                ? types.type
-                : types);
+function normalizeAllowedTypesInternal(type) {
+    if (isAnnotatedAllowedTypes(type)) {
+        return type;
+    }
+    // This caching accomplishes two things:
+    // 1. It avoids redundant computations for the same input.
+    // 2. It provides a stable object identity for the output in case the input is normalized twice and other systems (such as unhydrated contexts) are cached based on the object identity of the output.
+    // It is this second case which is the more important since creating the AnnotatedAllowedTypesInternal is rather cheap.
+    // Adding this cache improved the performance of the "large recursive union" test (which mostly just constructs a TreeConfiguration) by ~5 times.
+    // This cache is strictly a performance optimization: it is not required for correctness.
+    return (0, index_js_1.getOrCreate)(cachedNormalize, type, () => {
+        // Due to more specific internal type, the above does not narrow sufficiently, so more narrowing is needed.
+        // It is possible this will give a false error if a TreeNodeSchema which matches this check is used.
+        (0, internal_2.assert)(!("types" in type && "metadata" in type), "invalid AnnotatedAllowedTypes");
+        const annotatedTypes = ((0, index_js_1.isReadonlyArray)(type) ? type : [type]).map(normalizeToAnnotatedAllowedType);
+        return AnnotatedAllowedTypesInternal.create(annotatedTypes);
+    });
 }
-exports.unannotateImplicitAllowedTypes = unannotateImplicitAllowedTypes;
+exports.normalizeAllowedTypesInternal = normalizeAllowedTypesInternal;
 /**
- * Converts an {@link AnnotatedAllowedType} to an {@link LazyItem} by removing any annotations.
- * @remarks
- * This does not evaluate any lazy schemas.
+ * Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFullInternalEvaluated} 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 unannotateAllowedType(allowedType) {
-    return isAnnotatedAllowedType(allowedType)
-        ? allowedType.type
-        : allowedType;
+function normalizeAndEvaluateAnnotatedAllowedTypes(types) {
+    return normalizeAllowedTypesInternal(types).evaluate();
 }
-exports.unannotateAllowedType = unannotateAllowedType;
+exports.normalizeAndEvaluateAnnotatedAllowedTypes = normalizeAndEvaluateAnnotatedAllowedTypes;
 const cachedLazyItem = new WeakMap();
 /**
  * Returns the schema referenced by the {@link LazyItem}.