npm - @fluidframework/tree - Versions diffs - 2.72.0 → 2.73.0 - Mend

@fluidframework/tree 2.72.0 → 2.73.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (609) hide show

package/dist/simple-tree/core/allowedTypes.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"allowedTypes.js","sourceRoot":"","sources":["../../../src/simple-tree/core/allowedTypes.ts"],"names":[],"mappings":"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","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { Lazy } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\ttype ErasedBaseType,\n\tErasedTypeImplementation,\n} from \"@fluidframework/core-interfaces/internal\";\n\nimport {\n\tgetOrCreate,\n\tisReadonlyArray,\n\ttype IsUnion,\n\ttype MakeNominal,\n} from \"../../util/index.js\";\nimport { isLazy, type FlexListToUnion, type LazyItem } from \"./flexList.js\";\nimport {\n\tNodeKind,\n\ttype InsertableTypedNode,\n\ttype NodeFromSchema,\n\ttype TreeNodeSchema,\n} from \"./treeNodeSchema.js\";\nimport { schemaAsTreeNodeValid } from \"./treeNodeValid.js\";\nimport type { SimpleAllowedTypeAttributes } from \"../simpleSchema.js\";\n\n/\n Schema for types allowed in some location in a tree (like a field, map entry or array).\n * @remarks\n * Type constraint used in schema declaration APIs.\n \n The order of types in the array is not significant.\n * Additionally, it is legal for users of this type to have the runtime and compile time order of items within this array not match.\n * Therefor to ensure type safety, these arrays should not be indexed, and instead just be iterated.\n \n Ideally this restriction would be modeled in the type itself, but it is not ergonomic to do so as there is no easy (when compared to arrays)\n * way to declare and manipulate unordered sets of types in TypeScript.\n \n Duplicate entries in this array are not allowed and will produce runtime errors.\n * Duplicate types are allowed,\n * but this must only be reflected in the type and not the runtime values.\n * This duplication can be used to encode the typing when the number of items in the array is not known at compile time\n * but some of the items are known to be present unconditionally.\n * For example, typing `[typeof A] \| [typeof A, typeof B]` as `[typeof A, typeof B \| typeof A]` is allowed,\n * and can produce more useful {@link Input} types.\n \n Due to one implementation of this being {@link AllowedTypesFull}, it is not safe to assume this is an array (as determined by `Array.isArray`).\n \n Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.\n * @system @public\n /\nexport type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];\n\n/\n Stores annotations for an individual allowed type.\n * @remarks\n * Create using APIs on {@link SchemaStaticsBeta}, like {@link SchemaStaticsBeta.staged}.\n * @privateRemarks\n * Since this is sealed, users are not supposed to create instances of it directly.\n * Making it extend ErasedType could enforce that.\n * @beta\n * @sealed\n /\nexport interface AnnotatedAllowedType<T = LazyItem<TreeNodeSchema>> {\n\t/\n\t Annotations for the allowed type.\n\t /\n\treadonly metadata: AllowedTypeMetadata;\n\t/\n\t The allowed type the annotations apply to in a particular schema.\n\t /\n\treadonly type: T;\n}\n\n/\n {@link AllowedTypesFull} but with the lazy schema references eagerly evaluated.\n * @sealed\n * @beta\n /\nexport type AllowedTypesFullEvaluated = AllowedTypesFull<\n\treadonly AnnotatedAllowedType<TreeNodeSchema>[]\n>;\n\n/\n Checks if the input is an {@link AnnotatedAllowedTypes}.\n /\nexport function isAnnotatedAllowedTypes(\n\tallowedTypes: ImplicitAllowedTypes,\n): allowedTypes is AllowedTypesFullInternal {\n\tcheckForUninitializedSchema(allowedTypes);\n\treturn allowedTypes instanceof AnnotatedAllowedTypesInternal;\n}\n\n/\n Stores annotations for a set of allowed types.\n * @beta\n * @sealed\n /\nexport interface AnnotatedAllowedTypes<T = readonly AnnotatedAllowedType[]>\n\textends ErasedBaseType<\"tree.AnnotatedAllowedTypes\"> {\n\t/\n\t Annotations that apply to a set of allowed types.\n\t /\n\treadonly metadata: AllowedTypesMetadata;\n\n\t/\n\t All the allowed types that the annotations apply to. The types themselves may also have individual annotations.\n\t /\n\treadonly types: T;\n\n\t/\n\t Get this {@link AnnotatedAllowedTypes} but with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t /\n\tevaluate(): AllowedTypesFullEvaluated;\n\n\t/\n\t Get the allowed types as a set with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t /\n\tevaluateSet(): ReadonlySet<TreeNodeSchema>;\n\n\t/\n\t Get the allowed types as a set of identifiers with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t \n\t It is recommend to work in terms of {@link TreeNodeSchema}\n\t * rather than identifiers where possible since its more type safe and it is possible that two schema with the same identifier exist.\n\t /\n\tevaluateIdentifiers(): ReadonlySet<string>;\n}\n\n/\n Stores annotations for a set of allowed types.\n * @remarks\n * Most expressive form of AllowedTypes which any of the implicit types can be normalized to.\n * @beta\n * @sealed\n /\nexport type AllowedTypesFull<\n\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n> = AnnotatedAllowedTypes<T> & UnannotateAllowedTypesList<T>;\n\n/\n Creates an {@link AllowedTypesFull} type from a mixed array of annotated and unannotated allowed types.\n * @system @sealed @beta\n /\nexport type AllowedTypesFullFromMixed<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = UnannotateAllowedTypesList<T> & AnnotatedAllowedTypes<AnnotateAllowedTypesList<T>>;\n\n/\n The same as the built-in InstanceType, but works on classes with private constructors.\n * @privateRemarks\n * This is based on the trick in {@link https://stackoverflow.com/a/74657881}.\n /\ntype InstanceTypeRelaxed<TClass> = InstanceType<(new () => never) & TClass>;\n\n/\n {@link AllowedTypesFull} but with internal types.\n /\nexport type AllowedTypesFullInternal<\n\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n> = AnnotatedAllowedTypesInternal<T> & UnannotateAllowedTypesList<T>;\n\ntype AllowedTypesFullInternalEvaluated = AllowedTypesFullInternal<\n\treadonly AnnotatedAllowedType<TreeNodeSchema>[]\n>;\n\n/\n The implementation of {@link AnnotatedAllowedTypes}. Also implements {@link AllowedTypesFull}.\n * @remarks\n * Due to TypeScript limitations, this class cannot directly state it implements {@link AllowedTypesFull}.\n * As a workaround for that, the static `create` method returns the intersection type.\n /\nexport class AnnotatedAllowedTypesInternal<\n\t\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n\t>\n\textends ErasedTypeImplementation<AnnotatedAllowedTypes<T>>\n\timplements AnnotatedAllowedTypes<T>\n{\n\tpublic readonly unannotatedTypes: UnannotateAllowedTypesList<T>;\n\n\t/\n\t True if and only if there is at least one lazy schema reference in the types arrays.\n\t /\n\tprivate readonly isLazy: boolean;\n\n\tprivate readonly lazyEvaluate: Lazy<{\n\t\treadonly annotated: AllowedTypesFullInternalEvaluated;\n\t\treadonly set: ReadonlySet<TreeNodeSchema>;\n\t\treadonly identifiers: ReadonlySet<string>;\n\t}>;\n\n\tprivate constructor(\n\t\tpublic readonly types: T,\n\t\tpublic readonly metadata: AllowedTypesMetadata = {},\n\t) {\n\t\tsuper();\n\t\tthis.unannotatedTypes = types.map((type) => type.type) as typeof this.unannotatedTypes;\n\n\t\t// Since the array has been copied, mutations to it will not be handled correctly so freeze it.\n\t\t// Support for such mutations could be added at a later date by making more things lazy.\n\t\tObject.freeze(this.types);\n\t\tObject.freeze(this.unannotatedTypes);\n\n\t\tthis.isLazy = false;\n\t\tfor (const type of this.unannotatedTypes) {\n\t\t\tif (isLazy(type)) {\n\t\t\t\tthis.isLazy = true;\n\t\t\t} else {\n\t\t\t\tmarkSchemaMostDerived(type);\n\t\t\t}\n\t\t}\n\n\t\tconst proxy = AnnotatedAllowedTypesInternal.proxy(this);\n\n\t\tthis.lazyEvaluate = new Lazy(() => {\n\t\t\tconst annotated = this.isLazy\n\t\t\t\t? AnnotatedAllowedTypesInternal.create(\n\t\t\t\t\t\tthis.types.map((type) => ({\n\t\t\t\t\t\t\t...type,\n\t\t\t\t\t\t\ttype: evaluateLazySchema(type.type),\n\t\t\t\t\t\t})),\n\t\t\t\t\t\tthis.metadata,\n\t\t\t\t\t)\n\t\t\t\t: (proxy as AllowedTypesFullInternalEvaluated);\n\t\t\treturn {\n\t\t\t\tannotated,\n\t\t\t\tset: new Set(annotated.unannotatedTypes),\n\t\t\t\tidentifiers: new Set(annotated.unannotatedTypes.map((t) => t.identifier)),\n\t\t\t};\n\t\t});\n\n\t\treturn proxy;\n\t}\n\n\tpublic evaluate(): AllowedTypesFullInternalEvaluated {\n\t\treturn this.lazyEvaluate.value.annotated;\n\t}\n\n\tpublic evaluateSet(): ReadonlySet<TreeNodeSchema> {\n\t\treturn this.lazyEvaluate.value.set;\n\t}\n\n\tpublic evaluateIdentifiers(): ReadonlySet<string> {\n\t\treturn this.lazyEvaluate.value.identifiers;\n\t}\n\n\t/\n\t Get the {@link SimpleAllowedTypeAttributes} version of the allowed types set.\n\t /\n\tpublic static evaluateSimpleAllowedTypes(\n\t\tannotatedAllowedTypes: AnnotatedAllowedTypes,\n\t): ReadonlyMap<string, SimpleAllowedTypeAttributes> {\n\t\tconst simpleAllowedTypes = new Map<string, SimpleAllowedTypeAttributes>();\n\t\tfor (const type of annotatedAllowedTypes.evaluate().types) {\n\t\t\tsimpleAllowedTypes.set(type.type.identifier, {\n\t\t\t\tisStaged: type.metadata.stagedSchemaUpgrade !== undefined,\n\t\t\t});\n\t\t}\n\t\treturn simpleAllowedTypes;\n\t}\n\n\tpublic static override [Symbol.hasInstance]<TThis extends { prototype: object }>(\n\t\tthis: TThis,\n\t\tvalue: unknown,\n\t): value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull {\n\t\treturn ErasedTypeImplementation[Symbol.hasInstance].call(this, value);\n\t}\n\n\tpublic static override narrow<TThis extends { prototype: object }>(\n\t\tthis: TThis,\n\t\tvalue: ErasedBaseType \| InstanceTypeRelaxed<TThis> \| ImplicitAllowedTypes,\n\t): asserts value is InstanceTypeRelaxed<TThis> &\n\t\tAnnotatedAllowedTypesInternal &\n\t\tAllowedTypesFull {\n\t\tif (!ErasedTypeImplementation[Symbol.hasInstance].call(this, value)) {\n\t\t\tthrow new TypeError(\"Invalid AnnotatedAllowedTypes instance\");\n\t\t}\n\t}\n\n\tprivate static proxy<const T extends readonly AnnotatedAllowedType[]>(\n\t\tresult: AnnotatedAllowedTypesInternal<T>,\n\t): AnnotatedAllowedTypesInternal<T> & AllowedTypesFull<T> {\n\t\tconst proxy = new Proxy(result, {\n\t\t\tset: () => {\n\t\t\t\tthrow new UsageError(\"AnnotatedAllowedTypes is immutable\");\n\t\t\t},\n\n\t\t\tget: (target, property, receiver) => {\n\t\t\t\t// Hide common array editing methods.\n\t\t\t\tif (property === \"push\" \|\| property === \"pop\") {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\n\t\t\t\t// Forward array lookup and array methods to the unannotated types array.\n\t\t\t\tif (property in target.unannotatedTypes) {\n\t\t\t\t\treturn Reflect.get(target.unannotatedTypes, property);\n\t\t\t\t}\n\t\t\t\t// Forward anything else to target.\n\t\t\t\treturn Reflect.get(target, property) as unknown;\n\t\t\t},\n\n\t\t\thas: (target, property) => {\n\t\t\t\tif (property in target.unannotatedTypes) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\t// Forward anything else to target.\n\t\t\t\treturn property in target;\n\t\t\t},\n\n\t\t\townKeys: (target) => {\n\t\t\t\tconst targetKeys = Reflect.ownKeys(target);\n\t\t\t\tconst unannotatedTypesKeys = Reflect.ownKeys(target.unannotatedTypes);\n\t\t\t\treturn [...unannotatedTypesKeys, ...targetKeys];\n\t\t\t},\n\n\t\t\tgetOwnPropertyDescriptor: (target, property) => {\n\t\t\t\tif (Object.prototype.hasOwnProperty.call(target.unannotatedTypes, property)) {\n\t\t\t\t\tconst inner = Object.getOwnPropertyDescriptor(target.unannotatedTypes, property);\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...inner,\n\t\t\t\t\t\t// Since these properties are not on the target, make them non-configurable to confirm with proxy invariants.\n\t\t\t\t\t\tconfigurable: true,\n\t\t\t\t\t\twritable: false,\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\tconst inner = Object.getOwnPropertyDescriptor(target, property);\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...inner,\n\t\t\t\t\t\twritable: false,\n\t\t\t\t\t\t// Allow only array entries to be enumerable.\n\t\t\t\t\t\tenumerable: false,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t\treturn proxy as typeof result & UnannotateAllowedTypesList<T>;\n\t}\n\n\tpublic static create<const T extends readonly AnnotatedAllowedType[]>(\n\t\ttypes: T,\n\t\tmetadata: AllowedTypesMetadata = {},\n\t): AnnotatedAllowedTypesInternal<Readonly<T>> & AllowedTypesFull<Readonly<T>> {\n\t\tconst result = new AnnotatedAllowedTypesInternal(types, metadata);\n\t\treturn result as typeof result & UnannotateAllowedTypesList<T>;\n\t}\n\n\tpublic static createUnannotated<const T extends AllowedTypes>(\n\t\ttypes: T,\n\t\tmetadata: AllowedTypesMetadata = {},\n\t): AnnotatedAllowedTypesInternal & Readonly<T> {\n\t\tObject.freeze(types);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = types.map(normalizeToAnnotatedAllowedType);\n\t\tconst result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);\n\t\treturn result as typeof result & T;\n\t}\n\n\tpublic static createMixed<\n\t\tconst T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n\t>(types: T, metadata: AllowedTypesMetadata = {}): AllowedTypesFullFromMixed<T> {\n\t\tObject.freeze(types);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = types.map(normalizeToAnnotatedAllowedType);\n\t\tconst result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);\n\t\treturn result as AllowedTypesFullFromMixed<T>;\n\t}\n}\n\n/\n Annotations that apply to a set of allowed types.\n * @remarks\n * Additional optionals may be added to this as non-breaking changes, so implementations of it should be simple object literals with no unlisted members.\n * @beta\n * @input\n /\nexport interface AllowedTypesMetadata {\n\t/\n\t User defined metadata\n\t /\n\treadonly custom?: unknown;\n}\n\n/\n Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.\n /\nexport function isAnnotatedAllowedType(\n\tallowedType: AnnotatedAllowedType \| LazyItem<TreeNodeSchema>,\n): allowedType is AnnotatedAllowedType {\n\tcheckForUninitializedSchema(allowedType);\n\t// Class based schema, and lazy schema references report type \"function\": filtering them out with typeof makes narrowing based on members mostly safe\n\treturn typeof allowedType === \"object\" && \"metadata\" in allowedType && \"type\" in allowedType;\n}\n\n/\n Annotations that apply to an individual allowed type.\n * @remarks\n * Additional optionals may be added to this as non-breaking changes, so implementations of it should be simple object literals with no unlisted members.\n * @beta\n * @input\n /\nexport interface AllowedTypeMetadata {\n\t/\n\t User defined metadata\n\t /\n\treadonly custom?: unknown;\n\n\t/\n\t If defined, indicates that an allowed type is {@link SchemaStaticsBeta.staged \| staged}.\n\t /\n\treadonly stagedSchemaUpgrade?: SchemaUpgrade;\n}\n\n/\n Package internal {@link SchemaUpgrade} construction API.\n /\nexport let createSchemaUpgrade: () => SchemaUpgrade;\n\n/\n Unique token used to upgrade schemas and determine if a particular upgrade has been completed.\n * @remarks\n * Create using {@link SchemaStaticsBeta.staged}.\n * @privateRemarks\n * TODO:#38722 implement runtime schema upgrades.\n * Until then, the class purely behaves mostly as a placeholder.\n * TODO: Consider allowing users to store a name for the upgrade to use in error messages.\n * @sealed @beta\n /\nexport class SchemaUpgrade {\n\tprotected _typeCheck!: MakeNominal;\n\tstatic {\n\t\tcreateSchemaUpgrade = () => new SchemaUpgrade();\n\t}\n\n\tprivate constructor() {}\n}\n\n/\n Types of {@link TreeNode\|TreeNodes} or {@link TreeLeafValue\|TreeLeafValues} allowed at a location in a tree.\n * @remarks\n * Used by {@link TreeViewConfiguration} for the root and various kinds of {@link TreeNodeSchema} to specify their allowed child types.\n \n Use {@link SchemaFactory} to access leaf schema or declare new composite schema.\n \n Implicitly treats a single type as an array of one type.\n \n Arrays of schema can be used to specify multiple types are allowed, which result in unions of those types in the Tree APIs.\n \n When saved into variables, avoid type-erasing the details, as doing so loses the compile time schema awareness of APIs derived from the types.\n \n 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.\n * See {@link ValidateRecursiveSchema} for details on how to structure the `ImplicitAllowedTypes` instances when constructing recursive schema.\n \n Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.\n \n @example Explicit use with strong typing\n * ```typescript\n * const sf = new SchemaFactory(\"myScope\");\n * const childTypes = [sf.number, sf.string] as const satisfies ImplicitAllowedTypes;\n * const config = new TreeViewConfiguration({ schema: childTypes });\n * ```\n \n @example Forward reference\n * ```typescript\n * const sf = new SchemaFactory(\"myScope\");\n * class A extends sf.array(\"example\", [() => B]) {}\n * class B extends sf.array(\"Inner\", sf.number) {}\n * ```\n * @public\n /\nexport type ImplicitAllowedTypes = AllowedTypes \| TreeNodeSchema;\n\n/\n Removes annotations from a list of allowed types that may contain annotations.\n * @system @beta\n /\nexport type UnannotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: T[I] extends AnnotatedAllowedType<infer X> ? X : T[I];\n};\n\n/\n Add annotations to a list of allowed types that may or may not contain annotations.\n * @system @beta\n /\nexport type AnnotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: T[I] extends AnnotatedAllowedType<unknown>\n\t\t? T[I]\n\t\t: AnnotatedAllowedType<T[I]>;\n};\n\n/\n Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFull}.\n * @alpha\n /\nexport function normalizeAllowedTypes(types: ImplicitAllowedTypes): AllowedTypesFull {\n\treturn normalizeAllowedTypesInternal(types);\n}\n\n/\n Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.\n /\nexport function normalizeToAnnotatedAllowedType<T extends LazyItem<TreeNodeSchema>>(\n\ttype: T \| AnnotatedAllowedType<T>,\n): AnnotatedAllowedType<T> {\n\treturn isAnnotatedAllowedType(type)\n\t\t? type\n\t\t: {\n\t\t\t\tmetadata: {},\n\t\t\t\ttype,\n\t\t\t};\n}\n\n/\n See note inside {@link normalizeAllowedTypesInternal}.\n /\nconst cachedNormalize = new WeakMap<ImplicitAllowedTypes, AllowedTypesFullInternal>();\n\n/\n Normalizes allowed types to an {@link AllowedTypesFullInternal}.\n /\nexport function normalizeAllowedTypesInternal(\n\ttype: ImplicitAllowedTypes,\n): AllowedTypesFullInternal {\n\tif (isAnnotatedAllowedTypes(type)) {\n\t\treturn type;\n\t}\n\n\t// This caching accomplishes two things:\n\t// 1. It avoids redundant computations for the same input.\n\t// 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.\n\t// It is this second case which is the more important since creating the AnnotatedAllowedTypesInternal is rather cheap.\n\t// Adding this cache improved the performance of the \"large recursive union\" test (which mostly just constructs a TreeConfiguration) by ~5 times.\n\t// This cache is strictly a performance optimization: it is not required for correctness.\n\treturn getOrCreate(cachedNormalize, type, () => {\n\t\tconst inputArray = isReadonlyArray(type) ? type : [type];\n\t\tObject.freeze(inputArray);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = inputArray.map(\n\t\t\tnormalizeToAnnotatedAllowedType,\n\t\t);\n\n\t\treturn AnnotatedAllowedTypesInternal.create(annotatedTypes);\n\t});\n}\n\n/\n Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFullInternalEvaluated} by eagerly evaluating any\n * lazy schema declarations and adding empty metadata if it doesn't already exist.\n \n @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of\n * recursive schemas may fail.\n /\nexport function normalizeAndEvaluateAnnotatedAllowedTypes(\n\ttypes: ImplicitAllowedTypes,\n): AllowedTypesFullInternalEvaluated {\n\treturn normalizeAllowedTypesInternal(types).evaluate();\n}\n\nconst cachedLazyItem = new WeakMap<() => unknown, unknown>();\n\n/\n Returns the schema referenced by the {@link LazyItem}.\n * @remarks\n * Caches results to handle {@link LazyItem}s which compute their resulting schema.\n * @alpha\n /\nexport function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>): T {\n\tconst evaluatedSchema = isLazy(value)\n\t\t? (getOrCreate(cachedLazyItem, value, value) as T)\n\t\t: value;\n\n\tcheckForUninitializedSchema(evaluatedSchema);\n\tmarkSchemaMostDerived(evaluatedSchema);\n\treturn evaluatedSchema;\n}\n\n/\n Throws a UsageError if the provided schema is undefined, most likely due to being used before it was initialized.\n /\nexport function checkForUninitializedSchema(\n\tschema: ImplicitAllowedTypes \| LazyItem<TreeNodeSchema> \| AnnotatedAllowedType,\n): void {\n\tif (schema === undefined) {\n\t\tthrow new UsageError(\n\t\t\t`Encountered an undefined schema. This could indicate that some referenced schema has not yet been instantiated. Consider using a lazy schema reference (like \"() => schema\") or delaying the evaluation of the lazy reference if one is already being used.`,\n\t\t);\n\t}\n}\n\n/\n Indicates that the provided schema is the \"most derived\" version in its class hierarchy.\n \n @param oneTimeInitialize - If true this runs {@link TreeNodeValid.oneTimeInitialize} which does even more initialization and validation.\n * `oneTimeInitialize` can't safely be run until all transitively referenced schema are defined, so which cases can safely use it are more limited.\n * When legal for the caller to set this to true, it is preferred, but it is often not safe due to possible forward references.\n * @remarks\n * See {@link MostDerivedData} and {@link SchemaFactory} for details on what a \"most derived\" schema is and why it matters.\n \n This is a helper for invoking {@link TreeNodeValid.markMostDerived} for {@link TreeNodeSchema}.\n \n Calling this helps with error messages about invalid schema usage (See {@link SchemaFactory} for the rules, some of which this helps validate).\n * Typically this should be called for each schema as early as practical to improve error reporting for invalid usages of schema\n * (using two different schema derived from the same {@link SchemaFactory} produced base class).\n \n Note that construction of actual {@link TreeNode} instances or use of a schema transitively in a {@link TreeViewConfiguration} already do this,\n * so any calls to this that is unconditionally after that point for the given schema is not needed.\n * 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\n * pass in a base class of a schema instead of the most derived one.\n /\nexport function markSchemaMostDerived(\n\tschema: TreeNodeSchema,\n\toneTimeInitialize = false,\n): void {\n\t// Leaf schema are not classes, and thus do not need to be marked as most derived.\n\tif (schema.kind === NodeKind.Leaf) {\n\t\treturn;\n\t}\n\n\tconst schemaValid = schemaAsTreeNodeValid(schema);\n\n\tif (oneTimeInitialize) {\n\t\tschemaValid.oneTimeInitialize();\n\t} else {\n\t\tschemaValid.markMostDerived();\n\t}\n}\n\n/\n Type of tree node for a field of the given schema.\n * @public\n /\nexport type TreeNodeFromImplicitAllowedTypes<\n\tTSchema extends ImplicitAllowedTypes = TreeNodeSchema,\n> = TSchema extends TreeNodeSchema\n\t? NodeFromSchema<TSchema>\n\t: TSchema extends AllowedTypes\n\t\t? NodeFromSchema<FlexListToUnion<TSchema>>\n\t\t: unknown;\n\n/\n This type exists only to be linked from documentation to provide a single linkable place to document some details of\n * \"Input\" types and how they handle schema.\n \n When a schema is used to describe data which is an input into an API, the API is {@link https://en.wikipedia.org/wiki/Type_variance \| contravariant}) over the schema.\n * (See also {@link https://www.typescriptlang.org/docs/handbook/2/generics.html#variance-annotations \| TypeScript Variance Annotations}).\n \n Since these schema are expressed using TypeScript types, it is possible for the user of the API to provide non-exact values of these types which has implications that depended on the variance.\n \n Consider a field with schema type of `A \| B` (where A and B are types of schema).\n \n - Reading the field behaves covariantly so {@link NodeFromSchema} of `<A \| B>` is the same as `NodeFromSchema<A> \| NodeFromSchema<B>`, indicating that either type of node can be read from the field.\n \n - Writing to the field behaves contravariantly. Since it is unknown if the node actually has a schema `A` or a schema `B`, the only legal values (known to be in schema regardless of which schema the underlying node has) are values which are legal for both `A & B`.\n \n Note that this is distinct from the case where the schema is `[A, B]`.\n * In this case it is known that the field allows both A and B (the field can be set to an A or a B value).\n * When `A \| B` is used, the field might allow\n * A but not B (so assigning a B value would be out of schema),\n * B but not A (so assigning an A value would be out of schema)\n * or both A and B.\n \n This gets more extreme when given completely unspecified schema.\n * For example if a field is just provided {@link ImplicitFieldSchema}, nothing is known about the content of the field.\n * This means that reading the field (via {@link TreeFieldFromImplicitField}) can give any valid tree field content,\n * but there are no safe values which could be written to the field (since it is unknown what values would be out of schema) so {@link InsertableTreeFieldFromImplicitField} gives `never`.\n \n To implement this variance correctly, the computation of types for input and output have to use separate utilities\n * which take very different approaches when encountering non-exact schema like unions or `ImplicitFieldSchema`.\n * The utilities which behave contravariantly (as required to handle input correctly) link this documentation to indicate that this is how they behave.\n \n In addition to behaving contravariantly, these input type computation utilities often have further limitations.\n * This is due to TypeScript making it difficult to implement this contravariance exactly.\n * When faced with these implementation limitations these contravariant type computation utilities error on the side of producing overly strict requirements.\n * For example in the above case of `A \| B`, the utilities might compute an allowed insertable type as `never` even if there happens to be a common value accepted by both `A` and `B`.\n * Future versions of the API can relax these requirements as the type computations are made more accurate.\n \n For a more concrete example: if {@link InsertableTreeFieldFromImplicitField} produced `never` for a schema `A \| OptionalField<A>`,\n * a future version could instead return a more flexible but still safe type, like `A`.\n \n More generally: try to avoid providing non-exact schema, especially for the fields of other schema.\n * While these APIs attempt to handle such cases correctly, there are limitations and known bugs in this handling.\n * Code using non-exact schema is much more likely to have its compilation break due to updates of this package or even TypeScript,\n * and thus compilation breaks due to edge cases of non-exact schema handling, especially with recursive schema, are not considered breaking changes.\n * This may change as the API become more stable.\n \n @privateRemarks\n * There likely is a better way to share this documentation, but none was found at the time of writing.\n \n TODO: Once {@link InsertableField} is public, consider using it in the examples above.\n * @system @public\n /\nexport type Input<T extends never> = T;\n\n/\n Type of content that can be inserted into the tree for a node of the given schema.\n \n @see {@link Input}\n \n @typeparam TSchema - Schema to process.\n \n @privateRemarks\n * This is a bit overly conservative, since cases like `A \| [A]` give never and could give `A`.\n * @public\n /\nexport type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes> =\n\t[TSchema] extends [TreeNodeSchema]\n\t\t? InsertableTypedNode<TSchema>\n\t\t: [TSchema] extends [AllowedTypes]\n\t\t\t? InsertableTreeNodeFromAllowedTypes<TSchema>\n\t\t\t: never;\n\n/\n Type of content that can be inserted into the tree for a node of the given schema.\n \n @see {@link Input}\n \n @typeparam TList - AllowedTypes to process\n \n @privateRemarks\n * This loop is non-recursive to allow larger unions before hitting the recursion limit in TypeScript.\n * @system @public\n /\nexport type InsertableTreeNodeFromAllowedTypes<TList extends AllowedTypes> =\n\tIsUnion<TList> extends true\n\t\t? never\n\t\t: {\n\t\t\t\treadonly [Property in keyof TList]: [TList[Property]] extends [\n\t\t\t\t\tLazyItem<infer TSchema extends TreeNodeSchema>,\n\t\t\t\t]\n\t\t\t\t\t? InsertableTypedNode<TSchema>\n\t\t\t\t\t: never;\n\t\t\t}[NumberKeys<TList>];\n\n/\n Extracts the keys of `T` which are numbers.\n * @remarks\n * The keys are extracted as strings which can be used to index `T`.\n \n This handles cases like `{ x: 4 } & [5, 6]` returning `\"0\"` and `\"1\"`.\n * Such cases are difficult to handle since `keyof` includes `number` in such cases, but the type can not be indexed by `number`.\n * @system @public\n */\nexport type NumberKeys<\n\tT,\n\tTransformed = {\n\t\treadonly [Property in keyof T as number extends Property ? never : Property]: Property;\n\t},\n> = Transformed[`${number}` & keyof Transformed];\n"]}
1	+ {"version":3,"file":"allowedTypes.js","sourceRoot":"","sources":["../../../src/simple-tree/core/allowedTypes.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uEAAsE;AACtE,kEAA2D;AAE3D,uEAGkD;AAElD,kDAK6B;AAC7B,+CAA4E;AAC5E,2DAK6B;AAC7B,yDAA2D;AA4D3D;;GAEG;AACH,SAAgB,uBAAuB,CACtC,YAAkC;IAElC,2BAA2B,CAAC,YAAY,CAAC,CAAC;IAC1C,OAAO,YAAY,YAAY,6BAA6B,CAAC;AAC9D,CAAC;AALD,0DAKC;AAiFD;;;;;GAKG;AACH,MAAa,6BAGZ,SAAQ,mCAAkD;IAgB1D,YACiB,KAAQ,EACR,WAAiC,EAAE;QAEnD,KAAK,EAAE,CAAC;QAHQ,UAAK,GAAL,KAAK,CAAG;QACR,aAAQ,GAAR,QAAQ,CAA2B;QAGnD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAiC,CAAC;QAEvF,+FAA+F;QAC/F,wFAAwF;QACxF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAErC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1C,IAAI,IAAA,oBAAM,EAAC,IAAI,CAAC,EAAE,CAAC;gBAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACP,qBAAqB,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC;QACF,CAAC;QAED,MAAM,KAAK,GAAG,6BAA6B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAExD,IAAI,CAAC,YAAY,GAAG,IAAI,eAAI,CAAC,GAAG,EAAE;YACjC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM;gBAC5B,CAAC,CAAC,6BAA6B,CAAC,MAAM,CACpC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;oBACzB,GAAG,IAAI;oBACP,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;iBACnC,CAAC,CAAC,EACH,IAAI,CAAC,QAAQ,CACb;gBACF,CAAC,CAAE,KAA2C,CAAC;YAChD,OAAO;gBACN,SAAS;gBACT,GAAG,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC;gBACxC,WAAW,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;aACzE,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACd,CAAC;IAEM,QAAQ;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;IAC1C,CAAC;IAEM,WAAW;QACjB,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;IACpC,CAAC;IAEM,mBAAmB;QACzB,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,WAAW,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,0BAA0B,CACvC,qBAA4C;QAE5C,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAuC,CAAC;QAC1E,KAAK,MAAM,IAAI,IAAI,qBAAqB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC;YAC3D,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBAC5C,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,mBAAmB,IAAI,KAAK;aACpD,CAAC,CAAC;QACJ,CAAC;QACD,OAAO,kBAAkB,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAE1C,KAAc;QAEd,OAAO,mCAAwB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvE,CAAC;IAEM,MAAM,CAAU,MAAM,CAE5B,KAAyE;QAIzE,IAAI,CAAC,mCAAwB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;YACrE,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;QAC/D,CAAC;IACF,CAAC;IAEO,MAAM,CAAC,KAAK,CACnB,MAAwC;QAExC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;YAC/B,GAAG,EAAE,GAAG,EAAE;gBACT,MAAM,IAAI,qBAAU,CAAC,oCAAoC,CAAC,CAAC;YAC5D,CAAC;YAED,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;gBACnC,qCAAqC;gBACrC,IAAI,QAAQ,KAAK,MAAM,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;oBAC/C,OAAO,SAAS,CAAC;gBAClB,CAAC;gBAED,yEAAyE;gBACzE,IAAI,QAAQ,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;oBACzC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;gBACvD,CAAC;gBACD,mCAAmC;gBACnC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAY,CAAC;YACjD,CAAC;YAED,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;gBACzB,IAAI,QAAQ,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;oBACzC,OAAO,IAAI,CAAC;gBACb,CAAC;gBACD,mCAAmC;gBACnC,OAAO,QAAQ,IAAI,MAAM,CAAC;YAC3B,CAAC;YAED,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;gBACnB,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAC3C,MAAM,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBACtE,OAAO,CAAC,GAAG,oBAAoB,EAAE,GAAG,UAAU,CAAC,CAAC;YACjD,CAAC;YAED,wBAAwB,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;gBAC9C,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAC7E,MAAM,KAAK,GAAG,MAAM,CAAC,wBAAwB,CAAC,MAAM,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;oBACjF,OAAO;wBACN,GAAG,KAAK;wBACR,6GAA6G;wBAC7G,YAAY,EAAE,IAAI;wBAClB,QAAQ,EAAE,KAAK;qBACf,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACP,MAAM,KAAK,GAAG,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;oBAChE,OAAO;wBACN,GAAG,KAAK;wBACR,QAAQ,EAAE,KAAK;wBACf,6CAA6C;wBAC7C,UAAU,EAAE,KAAK;qBACjB,CAAC;gBACH,CAAC;YACF,CAAC;SACD,CAAC,CAAC;QACH,OAAO,KAAsD,CAAC;IAC/D,CAAC;IAEM,MAAM,CAAC,MAAM,CACnB,KAAQ,EACR,WAAiC,EAAE;QAEnC,MAAM,MAAM,GAAG,IAAI,6BAA6B,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAClE,OAAO,MAAuD,CAAC;IAChE,CAAC;IAEM,MAAM,CAAC,iBAAiB,CAC9B,KAAQ,EACR,WAAiC,EAAE;QAEnC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,MAAM,cAAc,GAA2B,KAAK,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAC1F,MAAM,MAAM,GAAG,6BAA6B,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAC9E,OAAO,MAA2B,CAAC;IACpC,CAAC;IAEM,MAAM,CAAC,WAAW,CAEvB,KAAQ,EAAE,WAAiC,EAAE;QAC9C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,MAAM,cAAc,GAA2B,KAAK,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAC1F,MAAM,MAAM,GAAG,6BAA6B,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAC9E,OAAO,MAAsC,CAAC;IAC/C,CAAC;CACD;AAhMD,sEAgMC;AAgBD;;GAEG;AACH,SAAgB,sBAAsB,CACrC,WAA4D;IAE5D,2BAA2B,CAAC,WAAW,CAAC,CAAC;IACzC,qJAAqJ;IACrJ,OAAO,OAAO,WAAW,KAAK,QAAQ,IAAI,UAAU,IAAI,WAAW,IAAI,MAAM,IAAI,WAAW,CAAC;AAC9F,CAAC;AAND,wDAMC;AA0BD;;;;;;;;;GASG;AACH,MAAa,aAAa;IAMzB,gBAAuB,CAAC;CACxB;AAPD,sCAOC;AALA;IACC,2BAAmB,GAAG,GAAG,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC;AACjD,CAAC,GAAA,CAAA;AA8DF;;;GAGG;AACH,SAAgB,qBAAqB,CAAC,KAA2B;IAChE,OAAO,6BAA6B,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC;AAFD,sDAEC;AAED;;GAEG;AACH,SAAgB,+BAA+B,CAC9C,IAAiC;IAEjC,OAAO,sBAAsB,CAAC,IAAI,CAAC;QAClC,CAAC,CAAC,IAAI;QACN,CAAC,CAAC;YACA,QAAQ,EAAE,EAAE;YACZ,IAAI;SACJ,CAAC;AACL,CAAC;AATD,0EASC;AAED;;GAEG;AACH,MAAM,eAAe,GAAG,IAAI,OAAO,EAAkD,CAAC;AAEtF;;GAEG;AACH,SAAgB,6BAA6B,CAC5C,IAA0B;IAE1B,IAAI,uBAAuB,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,wCAAwC;IACxC,0DAA0D;IAC1D,sMAAsM;IACtM,uHAAuH;IACvH,iJAAiJ;IACjJ,yFAAyF;IACzF,OAAO,IAAA,sBAAW,EAAC,eAAe,EAAE,IAAI,EAAE,GAAG,EAAE;QAC9C,MAAM,UAAU,GAAG,IAAA,0BAAe,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,MAAM,cAAc,GAA2B,UAAU,CAAC,GAAG,CAC5D,+BAA+B,CAC/B,CAAC;QAEF,OAAO,6BAA6B,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;AACJ,CAAC;AAtBD,sEAsBC;AAED;;;;;;GAMG;AACH,SAAgB,yCAAyC,CACxD,KAA2B;IAE3B,OAAO,6BAA6B,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;AACxD,CAAC;AAJD,8FAIC;AAED,MAAM,cAAc,GAAG,IAAI,OAAO,EAA0B,CAAC;AAE7D;;;;;GAKG;AACH,SAAgB,kBAAkB,CAA2B,KAAkB;IAC9E,MAAM,eAAe,GAAG,IAAA,oBAAM,EAAC,KAAK,CAAC;QACpC,CAAC,CAAE,IAAA,sBAAW,EAAC,cAAc,EAAE,KAAK,EAAE,KAAK,CAAO;QAClD,CAAC,CAAC,KAAK,CAAC;IAET,2BAA2B,CAAC,eAAe,CAAC,CAAC;IAC7C,qBAAqB,CAAC,eAAe,CAAC,CAAC;IACvC,OAAO,eAAe,CAAC;AACxB,CAAC;AARD,gDAQC;AAED;;GAEG;AACH,SAAgB,2BAA2B,CAC1C,MAA8E;IAE9E,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,qBAAU,CACnB,6PAA6P,CAC7P,CAAC;IACH,CAAC;AACF,CAAC;AARD,kEAQC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,qBAAqB,CACpC,MAAsB,EACtB,iBAAiB,GAAG,KAAK;IAEzB,kFAAkF;IAClF,IAAI,MAAM,CAAC,IAAI,KAAK,4BAAQ,CAAC,IAAI,EAAE,CAAC;QACnC,OAAO;IACR,CAAC;IAED,MAAM,WAAW,GAAG,IAAA,wCAAqB,EAAC,MAAM,CAAC,CAAC;IAElD,IAAI,iBAAiB,EAAE,CAAC;QACvB,WAAW,CAAC,iBAAiB,EAAE,CAAC;IACjC,CAAC;SAAM,CAAC;QACP,WAAW,CAAC,eAAe,EAAE,CAAC;IAC/B,CAAC;AACF,CAAC;AAhBD,sDAgBC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { Lazy } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\ttype ErasedBaseType,\n\tErasedTypeImplementation,\n} from \"@fluidframework/core-interfaces/internal\";\n\nimport {\n\tgetOrCreate,\n\tisReadonlyArray,\n\ttype IsUnion,\n\ttype MakeNominal,\n} from \"../../util/index.js\";\nimport { isLazy, type FlexListToUnion, type LazyItem } from \"./flexList.js\";\nimport {\n\tNodeKind,\n\ttype InsertableTypedNode,\n\ttype NodeFromSchema,\n\ttype TreeNodeSchema,\n} from \"./treeNodeSchema.js\";\nimport { schemaAsTreeNodeValid } from \"./treeNodeValid.js\";\nimport type { SimpleAllowedTypeAttributes } from \"../simpleSchema.js\";\n\n/\n Schema for types allowed in some location in a tree (like a field, map entry or array).\n * @remarks\n * Type constraint used in schema declaration APIs.\n \n The order of types in the array is not significant.\n * Additionally, it is legal for users of this type to have the runtime and compile time order of items within this array not match.\n * Therefor to ensure type safety, these arrays should not be indexed, and instead just be iterated.\n \n Ideally this restriction would be modeled in the type itself, but it is not ergonomic to do so as there is no easy (when compared to arrays)\n * way to declare and manipulate unordered sets of types in TypeScript.\n \n Duplicate entries in this array are not allowed and will produce runtime errors.\n * Duplicate types are allowed,\n * but this must only be reflected in the type and not the runtime values.\n * This duplication can be used to encode the typing when the number of items in the array is not known at compile time\n * but some of the items are known to be present unconditionally.\n * For example, typing `[typeof A] \| [typeof A, typeof B]` as `[typeof A, typeof B \| typeof A]` is allowed,\n * and can produce more useful {@link Input} types.\n \n Due to one implementation of this being {@link AllowedTypesFull}, it is not safe to assume this is an array (as determined by `Array.isArray`).\n \n Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.\n * @system @public\n /\nexport type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];\n\n/\n Stores annotations for an individual allowed type.\n * @remarks\n * Create using APIs on {@link SchemaStaticsBeta}, like {@link SchemaStaticsBeta.staged}.\n * @privateRemarks\n * Since this is sealed, users are not supposed to create instances of it directly.\n * Making it extend ErasedType could enforce that.\n * @beta\n * @sealed\n /\nexport interface AnnotatedAllowedType<T = LazyItem<TreeNodeSchema>> {\n\t/\n\t Annotations for the allowed type.\n\t /\n\treadonly metadata: AllowedTypeMetadata;\n\t/\n\t The allowed type the annotations apply to in a particular schema.\n\t /\n\treadonly type: T;\n}\n\n/\n {@link AllowedTypesFull} but with the lazy schema references eagerly evaluated.\n * @sealed\n * @beta\n /\nexport type AllowedTypesFullEvaluated = AllowedTypesFull<\n\treadonly AnnotatedAllowedType<TreeNodeSchema>[]\n>;\n\n/\n Checks if the input is an {@link AnnotatedAllowedTypes}.\n /\nexport function isAnnotatedAllowedTypes(\n\tallowedTypes: ImplicitAllowedTypes,\n): allowedTypes is AllowedTypesFullInternal {\n\tcheckForUninitializedSchema(allowedTypes);\n\treturn allowedTypes instanceof AnnotatedAllowedTypesInternal;\n}\n\n/\n Stores annotations for a set of allowed types.\n * @beta\n * @sealed\n /\nexport interface AnnotatedAllowedTypes<T = readonly AnnotatedAllowedType[]>\n\textends ErasedBaseType<\"tree.AnnotatedAllowedTypes\"> {\n\t/\n\t Annotations that apply to a set of allowed types.\n\t /\n\treadonly metadata: AllowedTypesMetadata;\n\n\t/\n\t All the allowed types that the annotations apply to. The types themselves may also have individual annotations.\n\t /\n\treadonly types: T;\n\n\t/\n\t Get this {@link AnnotatedAllowedTypes} but with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t /\n\tevaluate(): AllowedTypesFullEvaluated;\n\n\t/\n\t Get the allowed types as a set with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t /\n\tevaluateSet(): ReadonlySet<TreeNodeSchema>;\n\n\t/\n\t Get the allowed types as a set of identifiers with any lazy schema references eagerly evaluated.\n\t * @remarks\n\t * See {@link evaluateLazySchema} the implications of evaluating lazy schema references.\n\t \n\t It is recommend to work in terms of {@link TreeNodeSchema}\n\t * rather than identifiers where possible since its more type safe and it is possible that two schema with the same identifier exist.\n\t /\n\tevaluateIdentifiers(): ReadonlySet<string>;\n}\n\n/\n Stores annotations for a set of allowed types.\n * @remarks\n * Most expressive form of AllowedTypes which any of the implicit types can be normalized to.\n * @beta\n * @sealed\n /\nexport type AllowedTypesFull<\n\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n> = AnnotatedAllowedTypes<T> & UnannotateAllowedTypesList<T>;\n\n/\n Creates an {@link AllowedTypesFull} type from a mixed array of annotated and unannotated allowed types.\n * @system @sealed @beta\n /\nexport type AllowedTypesFullFromMixed<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = UnannotateAllowedTypesList<T> & AnnotatedAllowedTypes<AnnotateAllowedTypesList<T>>;\n\n/\n The same as the built-in InstanceType, but works on classes with private constructors.\n * @privateRemarks\n * This is based on the trick in {@link https://stackoverflow.com/a/74657881}.\n /\ntype InstanceTypeRelaxed<TClass> = InstanceType<(new () => never) & TClass>;\n\n/\n {@link AllowedTypesFull} but with internal types.\n /\nexport type AllowedTypesFullInternal<\n\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n> = AnnotatedAllowedTypesInternal<T> & UnannotateAllowedTypesList<T>;\n\ntype AllowedTypesFullInternalEvaluated = AllowedTypesFullInternal<\n\treadonly AnnotatedAllowedType<TreeNodeSchema>[]\n>;\n\n/\n The implementation of {@link AnnotatedAllowedTypes}. Also implements {@link AllowedTypesFull}.\n * @remarks\n * Due to TypeScript limitations, this class cannot directly state it implements {@link AllowedTypesFull}.\n * As a workaround for that, the static `create` method returns the intersection type.\n /\nexport class AnnotatedAllowedTypesInternal<\n\t\tT extends readonly AnnotatedAllowedType[] = readonly AnnotatedAllowedType[],\n\t>\n\textends ErasedTypeImplementation<AnnotatedAllowedTypes<T>>\n\timplements AnnotatedAllowedTypes<T>\n{\n\tpublic readonly unannotatedTypes: UnannotateAllowedTypesList<T>;\n\n\t/\n\t True if and only if there is at least one lazy schema reference in the types arrays.\n\t /\n\tprivate readonly isLazy: boolean;\n\n\tprivate readonly lazyEvaluate: Lazy<{\n\t\treadonly annotated: AllowedTypesFullInternalEvaluated;\n\t\treadonly set: ReadonlySet<TreeNodeSchema>;\n\t\treadonly identifiers: ReadonlySet<string>;\n\t}>;\n\n\tprivate constructor(\n\t\tpublic readonly types: T,\n\t\tpublic readonly metadata: AllowedTypesMetadata = {},\n\t) {\n\t\tsuper();\n\t\tthis.unannotatedTypes = types.map((type) => type.type) as typeof this.unannotatedTypes;\n\n\t\t// Since the array has been copied, mutations to it will not be handled correctly so freeze it.\n\t\t// Support for such mutations could be added at a later date by making more things lazy.\n\t\tObject.freeze(this.types);\n\t\tObject.freeze(this.unannotatedTypes);\n\n\t\tthis.isLazy = false;\n\t\tfor (const type of this.unannotatedTypes) {\n\t\t\tif (isLazy(type)) {\n\t\t\t\tthis.isLazy = true;\n\t\t\t} else {\n\t\t\t\tmarkSchemaMostDerived(type);\n\t\t\t}\n\t\t}\n\n\t\tconst proxy = AnnotatedAllowedTypesInternal.proxy(this);\n\n\t\tthis.lazyEvaluate = new Lazy(() => {\n\t\t\tconst annotated = this.isLazy\n\t\t\t\t? AnnotatedAllowedTypesInternal.create(\n\t\t\t\t\t\tthis.types.map((type) => ({\n\t\t\t\t\t\t\t...type,\n\t\t\t\t\t\t\ttype: evaluateLazySchema(type.type),\n\t\t\t\t\t\t})),\n\t\t\t\t\t\tthis.metadata,\n\t\t\t\t\t)\n\t\t\t\t: (proxy as AllowedTypesFullInternalEvaluated);\n\t\t\treturn {\n\t\t\t\tannotated,\n\t\t\t\tset: new Set(annotated.unannotatedTypes),\n\t\t\t\tidentifiers: new Set(annotated.unannotatedTypes.map((t) => t.identifier)),\n\t\t\t};\n\t\t});\n\n\t\treturn proxy;\n\t}\n\n\tpublic evaluate(): AllowedTypesFullInternalEvaluated {\n\t\treturn this.lazyEvaluate.value.annotated;\n\t}\n\n\tpublic evaluateSet(): ReadonlySet<TreeNodeSchema> {\n\t\treturn this.lazyEvaluate.value.set;\n\t}\n\n\tpublic evaluateIdentifiers(): ReadonlySet<string> {\n\t\treturn this.lazyEvaluate.value.identifiers;\n\t}\n\n\t/\n\t Get the {@link SimpleAllowedTypeAttributes} version of the allowed types set.\n\t /\n\tpublic static evaluateSimpleAllowedTypes(\n\t\tannotatedAllowedTypes: AnnotatedAllowedTypes,\n\t): ReadonlyMap<string, SimpleAllowedTypeAttributes> {\n\t\tconst simpleAllowedTypes = new Map<string, SimpleAllowedTypeAttributes>();\n\t\tfor (const type of annotatedAllowedTypes.evaluate().types) {\n\t\t\tsimpleAllowedTypes.set(type.type.identifier, {\n\t\t\t\tisStaged: type.metadata.stagedSchemaUpgrade ?? false,\n\t\t\t});\n\t\t}\n\t\treturn simpleAllowedTypes;\n\t}\n\n\tpublic static override [Symbol.hasInstance]<TThis extends { prototype: object }>(\n\t\tthis: TThis,\n\t\tvalue: unknown,\n\t): value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull {\n\t\treturn ErasedTypeImplementation[Symbol.hasInstance].call(this, value);\n\t}\n\n\tpublic static override narrow<TThis extends { prototype: object }>(\n\t\tthis: TThis,\n\t\tvalue: ErasedBaseType \| InstanceTypeRelaxed<TThis> \| ImplicitAllowedTypes,\n\t): asserts value is InstanceTypeRelaxed<TThis> &\n\t\tAnnotatedAllowedTypesInternal &\n\t\tAllowedTypesFull {\n\t\tif (!ErasedTypeImplementation[Symbol.hasInstance].call(this, value)) {\n\t\t\tthrow new TypeError(\"Invalid AnnotatedAllowedTypes instance\");\n\t\t}\n\t}\n\n\tprivate static proxy<const T extends readonly AnnotatedAllowedType[]>(\n\t\tresult: AnnotatedAllowedTypesInternal<T>,\n\t): AnnotatedAllowedTypesInternal<T> & AllowedTypesFull<T> {\n\t\tconst proxy = new Proxy(result, {\n\t\t\tset: () => {\n\t\t\t\tthrow new UsageError(\"AnnotatedAllowedTypes is immutable\");\n\t\t\t},\n\n\t\t\tget: (target, property, receiver) => {\n\t\t\t\t// Hide common array editing methods.\n\t\t\t\tif (property === \"push\" \|\| property === \"pop\") {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\n\t\t\t\t// Forward array lookup and array methods to the unannotated types array.\n\t\t\t\tif (property in target.unannotatedTypes) {\n\t\t\t\t\treturn Reflect.get(target.unannotatedTypes, property);\n\t\t\t\t}\n\t\t\t\t// Forward anything else to target.\n\t\t\t\treturn Reflect.get(target, property) as unknown;\n\t\t\t},\n\n\t\t\thas: (target, property) => {\n\t\t\t\tif (property in target.unannotatedTypes) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\t// Forward anything else to target.\n\t\t\t\treturn property in target;\n\t\t\t},\n\n\t\t\townKeys: (target) => {\n\t\t\t\tconst targetKeys = Reflect.ownKeys(target);\n\t\t\t\tconst unannotatedTypesKeys = Reflect.ownKeys(target.unannotatedTypes);\n\t\t\t\treturn [...unannotatedTypesKeys, ...targetKeys];\n\t\t\t},\n\n\t\t\tgetOwnPropertyDescriptor: (target, property) => {\n\t\t\t\tif (Object.prototype.hasOwnProperty.call(target.unannotatedTypes, property)) {\n\t\t\t\t\tconst inner = Object.getOwnPropertyDescriptor(target.unannotatedTypes, property);\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...inner,\n\t\t\t\t\t\t// Since these properties are not on the target, make them non-configurable to confirm with proxy invariants.\n\t\t\t\t\t\tconfigurable: true,\n\t\t\t\t\t\twritable: false,\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\tconst inner = Object.getOwnPropertyDescriptor(target, property);\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...inner,\n\t\t\t\t\t\twritable: false,\n\t\t\t\t\t\t// Allow only array entries to be enumerable.\n\t\t\t\t\t\tenumerable: false,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t\treturn proxy as typeof result & UnannotateAllowedTypesList<T>;\n\t}\n\n\tpublic static create<const T extends readonly AnnotatedAllowedType[]>(\n\t\ttypes: T,\n\t\tmetadata: AllowedTypesMetadata = {},\n\t): AnnotatedAllowedTypesInternal<Readonly<T>> & AllowedTypesFull<Readonly<T>> {\n\t\tconst result = new AnnotatedAllowedTypesInternal(types, metadata);\n\t\treturn result as typeof result & UnannotateAllowedTypesList<T>;\n\t}\n\n\tpublic static createUnannotated<const T extends AllowedTypes>(\n\t\ttypes: T,\n\t\tmetadata: AllowedTypesMetadata = {},\n\t): AnnotatedAllowedTypesInternal & Readonly<T> {\n\t\tObject.freeze(types);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = types.map(normalizeToAnnotatedAllowedType);\n\t\tconst result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);\n\t\treturn result as typeof result & T;\n\t}\n\n\tpublic static createMixed<\n\t\tconst T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n\t>(types: T, metadata: AllowedTypesMetadata = {}): AllowedTypesFullFromMixed<T> {\n\t\tObject.freeze(types);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = types.map(normalizeToAnnotatedAllowedType);\n\t\tconst result = AnnotatedAllowedTypesInternal.create(annotatedTypes, metadata);\n\t\treturn result as AllowedTypesFullFromMixed<T>;\n\t}\n}\n\n/\n Annotations that apply to a set of allowed types.\n * @remarks\n * Additional optionals may be added to this as non-breaking changes, so implementations of it should be simple object literals with no unlisted members.\n * @beta\n * @input\n /\nexport interface AllowedTypesMetadata {\n\t/\n\t User defined metadata\n\t /\n\treadonly custom?: unknown;\n}\n\n/\n Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.\n /\nexport function isAnnotatedAllowedType(\n\tallowedType: AnnotatedAllowedType \| LazyItem<TreeNodeSchema>,\n): allowedType is AnnotatedAllowedType {\n\tcheckForUninitializedSchema(allowedType);\n\t// Class based schema, and lazy schema references report type \"function\": filtering them out with typeof makes narrowing based on members mostly safe\n\treturn typeof allowedType === \"object\" && \"metadata\" in allowedType && \"type\" in allowedType;\n}\n\n/\n Annotations that apply to an individual allowed type.\n * @remarks\n * Additional optionals may be added to this as non-breaking changes, so implementations of it should be simple object literals with no unlisted members.\n * @beta\n * @input\n /\nexport interface AllowedTypeMetadata {\n\t/\n\t User defined metadata\n\t /\n\treadonly custom?: unknown;\n\n\t/\n\t If defined, indicates that an allowed type is {@link SchemaStaticsBeta.staged \| staged}.\n\t /\n\treadonly stagedSchemaUpgrade?: SchemaUpgrade;\n}\n\n/\n Package internal {@link SchemaUpgrade} construction API.\n /\nexport let createSchemaUpgrade: () => SchemaUpgrade;\n\n/\n Unique token used to upgrade schemas and determine if a particular upgrade has been completed.\n * @remarks\n * Create using {@link SchemaStaticsBeta.staged}.\n * @privateRemarks\n * TODO:#38722 implement runtime schema upgrades.\n * Until then, the class purely behaves mostly as a placeholder.\n * TODO: Consider allowing users to store a name for the upgrade to use in error messages.\n * @sealed @beta\n /\nexport class SchemaUpgrade {\n\tprotected _typeCheck!: MakeNominal;\n\tstatic {\n\t\tcreateSchemaUpgrade = () => new SchemaUpgrade();\n\t}\n\n\tprivate constructor() {}\n}\n\n/\n Types of {@link TreeNode\|TreeNodes} or {@link TreeLeafValue\|TreeLeafValues} allowed at a location in a tree.\n * @remarks\n * Used by {@link TreeViewConfiguration} for the root and various kinds of {@link TreeNodeSchema} to specify their allowed child types.\n \n Use {@link SchemaFactory} to access leaf schema or declare new composite schema.\n \n Implicitly treats a single type as an array of one type.\n \n Arrays of schema can be used to specify multiple types are allowed, which result in unions of those types in the Tree APIs.\n \n When saved into variables, avoid type-erasing the details, as doing so loses the compile time schema awareness of APIs derived from the types.\n \n 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.\n * See {@link ValidateRecursiveSchema} for details on how to structure the `ImplicitAllowedTypes` instances when constructing recursive schema.\n \n Code reading data from this should use {@link normalizeAllowedTypes} to ensure consistent handling, caching, nice errors etc.\n \n @example Explicit use with strong typing\n * ```typescript\n * const sf = new SchemaFactory(\"myScope\");\n * const childTypes = [sf.number, sf.string] as const satisfies ImplicitAllowedTypes;\n * const config = new TreeViewConfiguration({ schema: childTypes });\n * ```\n \n @example Forward reference\n * ```typescript\n * const sf = new SchemaFactory(\"myScope\");\n * class A extends sf.array(\"example\", [() => B]) {}\n * class B extends sf.array(\"Inner\", sf.number) {}\n * ```\n * @public\n /\nexport type ImplicitAllowedTypes = AllowedTypes \| TreeNodeSchema;\n\n/\n Removes annotations from a list of allowed types that may contain annotations.\n * @system @beta\n /\nexport type UnannotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: T[I] extends AnnotatedAllowedType<infer X> ? X : T[I];\n};\n\n/\n Add annotations to a list of allowed types that may or may not contain annotations.\n * @system @beta\n /\nexport type AnnotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: T[I] extends AnnotatedAllowedType<unknown>\n\t\t? T[I]\n\t\t: AnnotatedAllowedType<T[I]>;\n};\n\n/\n Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFull}.\n * @alpha\n /\nexport function normalizeAllowedTypes(types: ImplicitAllowedTypes): AllowedTypesFull {\n\treturn normalizeAllowedTypesInternal(types);\n}\n\n/\n Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.\n /\nexport function normalizeToAnnotatedAllowedType<T extends LazyItem<TreeNodeSchema>>(\n\ttype: T \| AnnotatedAllowedType<T>,\n): AnnotatedAllowedType<T> {\n\treturn isAnnotatedAllowedType(type)\n\t\t? type\n\t\t: {\n\t\t\t\tmetadata: {},\n\t\t\t\ttype,\n\t\t\t};\n}\n\n/\n See note inside {@link normalizeAllowedTypesInternal}.\n /\nconst cachedNormalize = new WeakMap<ImplicitAllowedTypes, AllowedTypesFullInternal>();\n\n/\n Normalizes allowed types to an {@link AllowedTypesFullInternal}.\n /\nexport function normalizeAllowedTypesInternal(\n\ttype: ImplicitAllowedTypes,\n): AllowedTypesFullInternal {\n\tif (isAnnotatedAllowedTypes(type)) {\n\t\treturn type;\n\t}\n\n\t// This caching accomplishes two things:\n\t// 1. It avoids redundant computations for the same input.\n\t// 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.\n\t// It is this second case which is the more important since creating the AnnotatedAllowedTypesInternal is rather cheap.\n\t// Adding this cache improved the performance of the \"large recursive union\" test (which mostly just constructs a TreeConfiguration) by ~5 times.\n\t// This cache is strictly a performance optimization: it is not required for correctness.\n\treturn getOrCreate(cachedNormalize, type, () => {\n\t\tconst inputArray = isReadonlyArray(type) ? type : [type];\n\t\tObject.freeze(inputArray);\n\t\tconst annotatedTypes: AnnotatedAllowedType[] = inputArray.map(\n\t\t\tnormalizeToAnnotatedAllowedType,\n\t\t);\n\n\t\treturn AnnotatedAllowedTypesInternal.create(annotatedTypes);\n\t});\n}\n\n/\n Normalizes an {@link ImplicitAllowedTypes} to an {@link AllowedTypesFullInternalEvaluated} by eagerly evaluating any\n * lazy schema declarations and adding empty metadata if it doesn't already exist.\n \n @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of\n * recursive schemas may fail.\n /\nexport function normalizeAndEvaluateAnnotatedAllowedTypes(\n\ttypes: ImplicitAllowedTypes,\n): AllowedTypesFullInternalEvaluated {\n\treturn normalizeAllowedTypesInternal(types).evaluate();\n}\n\nconst cachedLazyItem = new WeakMap<() => unknown, unknown>();\n\n/\n Returns the schema referenced by the {@link LazyItem}.\n * @remarks\n * Caches results to handle {@link LazyItem}s which compute their resulting schema.\n * @alpha\n /\nexport function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>): T {\n\tconst evaluatedSchema = isLazy(value)\n\t\t? (getOrCreate(cachedLazyItem, value, value) as T)\n\t\t: value;\n\n\tcheckForUninitializedSchema(evaluatedSchema);\n\tmarkSchemaMostDerived(evaluatedSchema);\n\treturn evaluatedSchema;\n}\n\n/\n Throws a UsageError if the provided schema is undefined, most likely due to being used before it was initialized.\n /\nexport function checkForUninitializedSchema(\n\tschema: ImplicitAllowedTypes \| LazyItem<TreeNodeSchema> \| AnnotatedAllowedType,\n): void {\n\tif (schema === undefined) {\n\t\tthrow new UsageError(\n\t\t\t`Encountered an undefined schema. This could indicate that some referenced schema has not yet been instantiated. Consider using a lazy schema reference (like \"() => schema\") or delaying the evaluation of the lazy reference if one is already being used.`,\n\t\t);\n\t}\n}\n\n/\n Indicates that the provided schema is the \"most derived\" version in its class hierarchy.\n \n @param oneTimeInitialize - If true this runs {@link TreeNodeValid.oneTimeInitialize} which does even more initialization and validation.\n * `oneTimeInitialize` can't safely be run until all transitively referenced schema are defined, so which cases can safely use it are more limited.\n * When legal for the caller to set this to true, it is preferred, but it is often not safe due to possible forward references.\n * @remarks\n * See {@link MostDerivedData} and {@link SchemaFactory} for details on what a \"most derived\" schema is and why it matters.\n \n This is a helper for invoking {@link TreeNodeValid.markMostDerived} for {@link TreeNodeSchema}.\n \n Calling this helps with error messages about invalid schema usage (See {@link SchemaFactory} for the rules, some of which this helps validate).\n * Typically this should be called for each schema as early as practical to improve error reporting for invalid usages of schema\n * (using two different schema derived from the same {@link SchemaFactory} produced base class).\n \n Note that construction of actual {@link TreeNode} instances or use of a schema transitively in a {@link TreeViewConfiguration} already do this,\n * so any calls to this that is unconditionally after that point for the given schema is not needed.\n * 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\n * pass in a base class of a schema instead of the most derived one.\n /\nexport function markSchemaMostDerived(\n\tschema: TreeNodeSchema,\n\toneTimeInitialize = false,\n): void {\n\t// Leaf schema are not classes, and thus do not need to be marked as most derived.\n\tif (schema.kind === NodeKind.Leaf) {\n\t\treturn;\n\t}\n\n\tconst schemaValid = schemaAsTreeNodeValid(schema);\n\n\tif (oneTimeInitialize) {\n\t\tschemaValid.oneTimeInitialize();\n\t} else {\n\t\tschemaValid.markMostDerived();\n\t}\n}\n\n/\n Type of tree node for a field of the given schema.\n * @public\n /\nexport type TreeNodeFromImplicitAllowedTypes<\n\tTSchema extends ImplicitAllowedTypes = TreeNodeSchema,\n> = TSchema extends TreeNodeSchema\n\t? NodeFromSchema<TSchema>\n\t: TSchema extends AllowedTypes\n\t\t? NodeFromSchema<FlexListToUnion<TSchema>>\n\t\t: unknown;\n\n/\n This type exists only to be linked from documentation to provide a single linkable place to document some details of\n * \"Input\" types and how they handle schema.\n \n When a schema is used to describe data which is an input into an API, the API is {@link https://en.wikipedia.org/wiki/Type_variance \| contravariant}) over the schema.\n * (See also {@link https://www.typescriptlang.org/docs/handbook/2/generics.html#variance-annotations \| TypeScript Variance Annotations}).\n \n Since these schema are expressed using TypeScript types, it is possible for the user of the API to provide non-exact values of these types which has implications that depended on the variance.\n \n Consider a field with schema type of `A \| B` (where A and B are types of schema).\n \n - Reading the field behaves covariantly so {@link NodeFromSchema} of `<A \| B>` is the same as `NodeFromSchema<A> \| NodeFromSchema<B>`, indicating that either type of node can be read from the field.\n \n - Writing to the field behaves contravariantly. Since it is unknown if the node actually has a schema `A` or a schema `B`, the only legal values (known to be in schema regardless of which schema the underlying node has) are values which are legal for both `A & B`.\n \n Note that this is distinct from the case where the schema is `[A, B]`.\n * In this case it is known that the field allows both A and B (the field can be set to an A or a B value).\n * When `A \| B` is used, the field might allow\n * A but not B (so assigning a B value would be out of schema),\n * B but not A (so assigning an A value would be out of schema)\n * or both A and B.\n \n This gets more extreme when given completely unspecified schema.\n * For example if a field is just provided {@link ImplicitFieldSchema}, nothing is known about the content of the field.\n * This means that reading the field (via {@link TreeFieldFromImplicitField}) can give any valid tree field content,\n * but there are no safe values which could be written to the field (since it is unknown what values would be out of schema) so {@link InsertableTreeFieldFromImplicitField} gives `never`.\n \n To implement this variance correctly, the computation of types for input and output have to use separate utilities\n * which take very different approaches when encountering non-exact schema like unions or `ImplicitFieldSchema`.\n * The utilities which behave contravariantly (as required to handle input correctly) link this documentation to indicate that this is how they behave.\n \n In addition to behaving contravariantly, these input type computation utilities often have further limitations.\n * This is due to TypeScript making it difficult to implement this contravariance exactly.\n * When faced with these implementation limitations these contravariant type computation utilities error on the side of producing overly strict requirements.\n * For example in the above case of `A \| B`, the utilities might compute an allowed insertable type as `never` even if there happens to be a common value accepted by both `A` and `B`.\n * Future versions of the API can relax these requirements as the type computations are made more accurate.\n \n For a more concrete example: if {@link InsertableTreeFieldFromImplicitField} produced `never` for a schema `A \| OptionalField<A>`,\n * a future version could instead return a more flexible but still safe type, like `A`.\n \n More generally: try to avoid providing non-exact schema, especially for the fields of other schema.\n * While these APIs attempt to handle such cases correctly, there are limitations and known bugs in this handling.\n * Code using non-exact schema is much more likely to have its compilation break due to updates of this package or even TypeScript,\n * and thus compilation breaks due to edge cases of non-exact schema handling, especially with recursive schema, are not considered breaking changes.\n * This may change as the API become more stable.\n \n @privateRemarks\n * There likely is a better way to share this documentation, but none was found at the time of writing.\n \n TODO: Once {@link InsertableField} is public, consider using it in the examples above.\n * @system @public\n /\nexport type Input<T extends never> = T;\n\n/\n Type of content that can be inserted into the tree for a node of the given schema.\n \n @see {@link Input}\n \n @typeparam TSchema - Schema to process.\n \n @privateRemarks\n * This is a bit overly conservative, since cases like `A \| [A]` give never and could give `A`.\n * @public\n /\nexport type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes> =\n\t[TSchema] extends [TreeNodeSchema]\n\t\t? InsertableTypedNode<TSchema>\n\t\t: [TSchema] extends [AllowedTypes]\n\t\t\t? InsertableTreeNodeFromAllowedTypes<TSchema>\n\t\t\t: never;\n\n/\n Type of content that can be inserted into the tree for a node of the given schema.\n \n @see {@link Input}\n \n @typeparam TList - AllowedTypes to process\n \n @privateRemarks\n * This loop is non-recursive to allow larger unions before hitting the recursion limit in TypeScript.\n * @system @public\n /\nexport type InsertableTreeNodeFromAllowedTypes<TList extends AllowedTypes> =\n\tIsUnion<TList> extends true\n\t\t? never\n\t\t: {\n\t\t\t\treadonly [Property in keyof TList]: [TList[Property]] extends [\n\t\t\t\t\tLazyItem<infer TSchema extends TreeNodeSchema>,\n\t\t\t\t]\n\t\t\t\t\t? InsertableTypedNode<TSchema>\n\t\t\t\t\t: never;\n\t\t\t}[NumberKeys<TList>];\n\n/\n Extracts the keys of `T` which are numbers.\n * @remarks\n * The keys are extracted as strings which can be used to index `T`.\n \n This handles cases like `{ x: 4 } & [5, 6]` returning `\"0\"` and `\"1\"`.\n * Such cases are difficult to handle since `keyof` includes `number` in such cases, but the type can not be indexed by `number`.\n * @system @public\n */\nexport type NumberKeys<\n\tT,\n\tTransformed = {\n\t\treadonly [Property in keyof T as number extends Property ? never : Property]: Property;\n\t},\n> = Transformed[`${number}` & keyof Transformed];\n"]}

package/dist/simple-tree/core/index.d.ts CHANGED Viewed

@@ -8,8 +8,8 @@ export { type Unhydrated, type InternalTreeNode, } from "./types.js";
 export { TreeNode, privateToken, inPrototypeChain, } from "./treeNode.js";
 export { NodeKind, isTreeNodeSchemaClass, privateDataSymbol, getTreeNodeSchemaPrivateData, CompatibilityLevel, } from "./treeNodeSchema.js";
 export type { TreeNodeSchema, TreeNodeSchemaClass, TreeNodeSchemaNonClass, TreeNodeSchemaCore, TreeNodeSchemaBoth, NodeSchemaMetadata, TreeLeafValue, InsertableTypedNode, NodeBuilderData, NodeFromSchema, TreeNodeSchemaCorePrivate, TreeNodeSchemaPrivateData, TreeNodeSchemaInitializedData, FlexContent, } from "./treeNodeSchema.js";
-export { isAnnotatedAllowedTypes, isAnnotatedAllowedType, normalizeAllowedTypes, normalizeAndEvaluateAnnotatedAllowedTypes, normalizeToAnnotatedAllowedType, markSchemaMostDerived, evaluateLazySchema, createSchemaUpgrade, AnnotatedAllowedTypesInternal, normalizeAllowedTypesInternal, } from "./allowedTypes.js";
-export type { AnnotatedAllowedType, AllowedTypesFullEvaluated, ImplicitAllowedTypes, AllowedTypesMetadata, AllowedTypes, TreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromAllowedTypes, Input, UnannotateAllowedTypesList, AllowedTypeMetadata, AnnotatedAllowedTypes, AnnotateAllowedTypesList, SchemaUpgrade, AllowedTypesFullInternal, AllowedTypesFull, AllowedTypesFullFromMixed, NumberKeys, } from "./allowedTypes.js";
+export { isAnnotatedAllowedTypes, isAnnotatedAllowedType, normalizeAllowedTypes, normalizeAndEvaluateAnnotatedAllowedTypes, normalizeToAnnotatedAllowedType, markSchemaMostDerived, evaluateLazySchema, createSchemaUpgrade, AnnotatedAllowedTypesInternal, normalizeAllowedTypesInternal, SchemaUpgrade, } from "./allowedTypes.js";
+export type { AnnotatedAllowedType, AllowedTypesFullEvaluated, ImplicitAllowedTypes, AllowedTypesMetadata, AllowedTypes, TreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromAllowedTypes, Input, UnannotateAllowedTypesList, AllowedTypeMetadata, AnnotatedAllowedTypes, AnnotateAllowedTypesList, AllowedTypesFullInternal, AllowedTypesFull, AllowedTypesFullFromMixed, NumberKeys, } from "./allowedTypes.js";
 export { walkAllowedTypes, walkNodeSchema, type SchemaVisitor } from "./walkSchema.js";
 export { Context, HydratedContext } from "./context.js";
 export { getOrCreateNodeFromInnerNode, getOrCreateNodeFromInnerUnboxedNode, } from "./getOrCreateNode.js";
@@ -18,5 +18,5 @@ export type { LazyItem, FlexList, FlexListToUnion, ExtractItemType, } from "./fl
 export { isLazy } from "./flexList.js";
 export { TreeNodeValid, type MostDerivedData, createTreeNodeSchemaPrivateData, isClassBasedSchema, } from "./treeNodeValid.js";
 export type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
-export { type StoredSchemaGenerationOptions, convertAllowedTypes, allowedTypeFilter, } from "./toStored.js";
+export { type StoredSchemaGenerationOptions, convertAllowedTypes, allowedTypeFilter, type StoredFromViewSchemaGenerationOptions, ExpectStored, } from "./toStored.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/simple-tree/core/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EACV,cAAc,EACd,SAAS,EACT,oBAAoB,EACpB,KAAK,SAAS,EACd,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,gCAAgC,EAChC,iBAAiB,EACjB,sBAAsB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,KAAK,QAAQ,EACb,cAAc,EACd,gBAAgB,EAChB,mBAAmB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,KAAK,UAAU,EACf,KAAK,gBAAgB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,QAAQ,EACR,YAAY,EACZ,gBAAgB,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,QAAQ,EACR,qBAAqB,EACrB,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACX,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,WAAW,GACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,yCAAyC,EACzC,+BAA+B,EAC/B,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,6BAA6B,~~GAC7B~~,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACX,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,gCAAgC,EAChC,0CAA0C,EAC1C,kCAAkC,EAClC,KAAK,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,EACxB,~~aAAa,EACb,~~wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,UAAU,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EACN,4BAA4B,EAC5B,mCAAmC,GACnC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,WAAW,GACX,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACX,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,eAAe,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EACN,aAAa,EACb,KAAK,eAAe,EACpB,+BAA+B,EAC/B,kBAAkB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EACN,KAAK,6BAA6B,EAClC,mBAAmB,EACnB,iBAAiB,~~GACjB~~,MAAM,eAAe,CAAC"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EACV,cAAc,EACd,SAAS,EACT,oBAAoB,EACpB,KAAK,SAAS,EACd,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,gCAAgC,EAChC,iBAAiB,EACjB,sBAAsB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,KAAK,QAAQ,EACb,cAAc,EACd,gBAAgB,EAChB,mBAAmB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,KAAK,UAAU,EACf,KAAK,gBAAgB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,QAAQ,EACR,YAAY,EACZ,gBAAgB,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,QAAQ,EACR,qBAAqB,EACrB,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACX,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,WAAW,GACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,yCAAyC,EACzC,+BAA+B,EAC/B,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,6BAA6B,EAC7B,aAAa,GACb,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACX,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,gCAAgC,EAChC,0CAA0C,EAC1C,kCAAkC,EAClC,KAAK,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,UAAU,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EACN,4BAA4B,EAC5B,mCAAmC,GACnC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,WAAW,GACX,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACX,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,eAAe,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EACN,aAAa,EACb,KAAK,eAAe,EACpB,+BAA+B,EAC/B,kBAAkB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EACN,KAAK,6BAA6B,EAClC,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,qCAAqC,EAC1C,YAAY,GACZ,MAAM,eAAe,CAAC"}

package/dist/simple-tree/core/index.js CHANGED Viewed

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allowedTypeFilter = exports.convertAllowedTypes = exports.isClassBasedSchema = exports.createTreeNodeSchemaPrivateData = exports.TreeNodeValid = exports.isLazy = exports.createField = exports.UnhydratedContext = exports.UnhydratedSequenceField = exports.UnhydratedFlexTreeNode = exports.UnhydratedFlexTreeField = exports.getOrCreateNodeFromInnerUnboxedNode = exports.getOrCreateNodeFromInnerNode = exports.HydratedContext = exports.Context = exports.walkNodeSchema = exports.walkAllowedTypes = exports.normalizeAllowedTypesInternal = exports.AnnotatedAllowedTypesInternal = exports.createSchemaUpgrade = exports.evaluateLazySchema = exports.markSchemaMostDerived = exports.normalizeToAnnotatedAllowedType = exports.normalizeAndEvaluateAnnotatedAllowedTypes = exports.normalizeAllowedTypes = exports.isAnnotatedAllowedType = exports.isAnnotatedAllowedTypes = exports.CompatibilityLevel = exports.getTreeNodeSchemaPrivateData = exports.privateDataSymbol = exports.isTreeNodeSchemaClass = exports.NodeKind = exports.inPrototypeChain = exports.privateToken = exports.TreeNode = exports.contentSchemaSymbol = exports.typeSchemaSymbol = exports.typeNameSymbol = exports.withBufferedTreeEvents = exports.SimpleContextSlot = exports.getSimpleNodeSchemaFromInnerNode = exports.treeNodeFromAnchor = exports.getInnerNode = exports.tryDisposeTreeNode = exports.tryGetTreeNodeSchema = exports.getKernel = exports.TreeNodeKernel = exports.isTreeNode = void 0;
+exports.ExpectStored = exports.allowedTypeFilter = exports.convertAllowedTypes = exports.isClassBasedSchema = exports.createTreeNodeSchemaPrivateData = exports.TreeNodeValid = exports.isLazy = exports.createField = exports.UnhydratedContext = exports.UnhydratedSequenceField = exports.UnhydratedFlexTreeNode = exports.UnhydratedFlexTreeField = exports.getOrCreateNodeFromInnerUnboxedNode = exports.getOrCreateNodeFromInnerNode = exports.HydratedContext = exports.Context = exports.walkNodeSchema = exports.walkAllowedTypes = exports.SchemaUpgrade = exports.normalizeAllowedTypesInternal = exports.AnnotatedAllowedTypesInternal = exports.createSchemaUpgrade = exports.evaluateLazySchema = exports.markSchemaMostDerived = exports.normalizeToAnnotatedAllowedType = exports.normalizeAndEvaluateAnnotatedAllowedTypes = exports.normalizeAllowedTypes = exports.isAnnotatedAllowedType = exports.isAnnotatedAllowedTypes = exports.CompatibilityLevel = exports.getTreeNodeSchemaPrivateData = exports.privateDataSymbol = exports.isTreeNodeSchemaClass = exports.NodeKind = exports.inPrototypeChain = exports.privateToken = exports.TreeNode = exports.contentSchemaSymbol = exports.typeSchemaSymbol = exports.typeNameSymbol = exports.withBufferedTreeEvents = exports.SimpleContextSlot = exports.getSimpleNodeSchemaFromInnerNode = exports.treeNodeFromAnchor = exports.getInnerNode = exports.tryDisposeTreeNode = exports.tryGetTreeNodeSchema = exports.getKernel = exports.TreeNodeKernel = exports.isTreeNode = void 0;
 var treeNodeKernel_js_1 = require("./treeNodeKernel.js");
 Object.defineProperty(exports, "isTreeNode", { enumerable: true, get: function () { return treeNodeKernel_js_1.isTreeNode; } });
 Object.defineProperty(exports, "TreeNodeKernel", { enumerable: true, get: function () { return treeNodeKernel_js_1.TreeNodeKernel; } });
@@ -41,6 +41,7 @@ Object.defineProperty(exports, "evaluateLazySchema", { enumerable: true, get: fu
 Object.defineProperty(exports, "createSchemaUpgrade", { enumerable: true, get: function () { return allowedTypes_js_1.createSchemaUpgrade; } });
 Object.defineProperty(exports, "AnnotatedAllowedTypesInternal", { enumerable: true, get: function () { return allowedTypes_js_1.AnnotatedAllowedTypesInternal; } });
 Object.defineProperty(exports, "normalizeAllowedTypesInternal", { enumerable: true, get: function () { return allowedTypes_js_1.normalizeAllowedTypesInternal; } });
+Object.defineProperty(exports, "SchemaUpgrade", { enumerable: true, get: function () { return allowedTypes_js_1.SchemaUpgrade; } });
 var walkSchema_js_1 = require("./walkSchema.js");
 Object.defineProperty(exports, "walkAllowedTypes", { enumerable: true, get: function () { return walkSchema_js_1.walkAllowedTypes; } });
 Object.defineProperty(exports, "walkNodeSchema", { enumerable: true, get: function () { return walkSchema_js_1.walkNodeSchema; } });
@@ -65,4 +66,5 @@ Object.defineProperty(exports, "isClassBasedSchema", { enumerable: true, get: fu
 var toStored_js_1 = require("./toStored.js");
 Object.defineProperty(exports, "convertAllowedTypes", { enumerable: true, get: function () { return toStored_js_1.convertAllowedTypes; } });
 Object.defineProperty(exports, "allowedTypeFilter", { enumerable: true, get: function () { return toStored_js_1.allowedTypeFilter; } });
+Object.defineProperty(exports, "ExpectStored", { enumerable: true, get: function () { return toStored_js_1.ExpectStored; } });
 //# sourceMappingURL=index.js.map

package/dist/simple-tree/core/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,yDAY6B;AAX5B,+GAAA,UAAU,OAAA;AACV,mHAAA,cAAc,OAAA;AACd,8GAAA,SAAS,OAAA;AACT,yHAAA,oBAAoB,OAAA;AAEpB,uHAAA,kBAAkB,OAAA;AAClB,iHAAA,YAAY,OAAA;AACZ,uHAAA,kBAAkB,OAAA;AAClB,qIAAA,gCAAgC,OAAA;AAChC,sHAAA,iBAAiB,OAAA;AACjB,2HAAA,sBAAsB,OAAA;AAEvB,6CAKuB;AAHtB,6GAAA,cAAc,OAAA;AACd,+GAAA,gBAAgB,OAAA;AAChB,kHAAA,mBAAmB,OAAA;AAMpB,6CAIuB;AAHtB,uGAAA,QAAQ,OAAA;AACR,2GAAA,YAAY,OAAA;AACZ,+GAAA,gBAAgB,OAAA;AAEjB,yDAM6B;AAL5B,6GAAA,QAAQ,OAAA;AACR,0HAAA,qBAAqB,OAAA;AACrB,sHAAA,iBAAiB,OAAA;AACjB,iIAAA,4BAA4B,OAAA;AAC5B,uHAAA,kBAAkB,OAAA;AAkBnB,~~qDAW2B~~;~~AAV1B~~,0HAAA,uBAAuB,OAAA;AACvB,yHAAA,sBAAsB,OAAA;AACtB,wHAAA,qBAAqB,OAAA;AACrB,4IAAA,yCAAyC,OAAA;AACzC,kIAAA,+BAA+B,OAAA;AAC/B,wHAAA,qBAAqB,OAAA;AACrB,qHAAA,kBAAkB,OAAA;AAClB,sHAAA,mBAAmB,OAAA;AACnB,gIAAA,6BAA6B,OAAA;AAC7B,gIAAA,6BAA6B,OAAA;~~AAsB9B~~,iDAAuF;AAA9E,iHAAA,gBAAgB,OAAA;AAAE,+GAAA,cAAc,OAAA;AACzC,2CAAwD;AAA/C,qGAAA,OAAO,OAAA;AAAE,6GAAA,eAAe,OAAA;AACjC,2DAG8B;AAF7B,kIAAA,4BAA4B,OAAA;AAC5B,yIAAA,mCAAmC,OAAA;AAEpC,iEAMiC;AALhC,gIAAA,uBAAuB,OAAA;AACvB,+HAAA,sBAAsB,OAAA;AACtB,gIAAA,uBAAuB,OAAA;AACvB,0HAAA,iBAAiB,OAAA;AACjB,oHAAA,WAAW,OAAA;AAQZ,6CAAuC;AAA9B,qGAAA,MAAM,OAAA;AACf,uDAK4B;AAJ3B,iHAAA,aAAa,OAAA;AAEb,mIAAA,+BAA+B,OAAA;AAC/B,sHAAA,kBAAkB,OAAA;AAGnB,~~6CAIuB~~;~~AAFtB~~,kHAAA,mBAAmB,OAAA;AACnB,gHAAA,iBAAiB,OAAA","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tisTreeNode,\n\tTreeNodeKernel,\n\tgetKernel,\n\ttryGetTreeNodeSchema,\n\ttype InnerNode,\n\ttryDisposeTreeNode,\n\tgetInnerNode,\n\ttreeNodeFromAnchor,\n\tgetSimpleNodeSchemaFromInnerNode,\n\tSimpleContextSlot,\n\twithBufferedTreeEvents,\n} from \"./treeNodeKernel.js\";\nexport {\n\ttype WithType,\n\ttypeNameSymbol,\n\ttypeSchemaSymbol,\n\tcontentSchemaSymbol,\n} from \"./withType.js\";\nexport {\n\ttype Unhydrated,\n\ttype InternalTreeNode,\n} from \"./types.js\";\nexport {\n\tTreeNode,\n\tprivateToken,\n\tinPrototypeChain,\n} from \"./treeNode.js\";\nexport {\n\tNodeKind,\n\tisTreeNodeSchemaClass,\n\tprivateDataSymbol,\n\tgetTreeNodeSchemaPrivateData,\n\tCompatibilityLevel,\n} from \"./treeNodeSchema.js\";\nexport type {\n\tTreeNodeSchema,\n\tTreeNodeSchemaClass,\n\tTreeNodeSchemaNonClass,\n\tTreeNodeSchemaCore,\n\tTreeNodeSchemaBoth,\n\tNodeSchemaMetadata,\n\tTreeLeafValue,\n\tInsertableTypedNode,\n\tNodeBuilderData,\n\tNodeFromSchema,\n\tTreeNodeSchemaCorePrivate,\n\tTreeNodeSchemaPrivateData,\n\tTreeNodeSchemaInitializedData,\n\tFlexContent,\n} from \"./treeNodeSchema.js\";\nexport {\n\tisAnnotatedAllowedTypes,\n\tisAnnotatedAllowedType,\n\tnormalizeAllowedTypes,\n\tnormalizeAndEvaluateAnnotatedAllowedTypes,\n\tnormalizeToAnnotatedAllowedType,\n\tmarkSchemaMostDerived,\n\tevaluateLazySchema,\n\tcreateSchemaUpgrade,\n\tAnnotatedAllowedTypesInternal,\n\tnormalizeAllowedTypesInternal,\n} from \"./allowedTypes.js\";\nexport type {\n\tAnnotatedAllowedType,\n\tAllowedTypesFullEvaluated,\n\tImplicitAllowedTypes,\n\tAllowedTypesMetadata,\n\tAllowedTypes,\n\tTreeNodeFromImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tInsertableTreeNodeFromAllowedTypes,\n\tInput,\n\tUnannotateAllowedTypesList,\n\tAllowedTypeMetadata,\n\tAnnotatedAllowedTypes,\n\tAnnotateAllowedTypesList,\n\~~tSchemaUpgrade,\n\~~tAllowedTypesFullInternal,\n\tAllowedTypesFull,\n\tAllowedTypesFullFromMixed,\n\tNumberKeys,\n} from \"./allowedTypes.js\";\nexport { walkAllowedTypes, walkNodeSchema, type SchemaVisitor } from \"./walkSchema.js\";\nexport { Context, HydratedContext } from \"./context.js\";\nexport {\n\tgetOrCreateNodeFromInnerNode,\n\tgetOrCreateNodeFromInnerUnboxedNode,\n} from \"./getOrCreateNode.js\";\nexport {\n\tUnhydratedFlexTreeField,\n\tUnhydratedFlexTreeNode,\n\tUnhydratedSequenceField,\n\tUnhydratedContext,\n\tcreateField,\n} from \"./unhydratedFlexTree.js\";\nexport type {\n\tLazyItem,\n\tFlexList,\n\tFlexListToUnion,\n\tExtractItemType,\n} from \"./flexList.js\";\nexport { isLazy } from \"./flexList.js\";\nexport {\n\tTreeNodeValid,\n\ttype MostDerivedData,\n\tcreateTreeNodeSchemaPrivateData,\n\tisClassBasedSchema,\n} from \"./treeNodeValid.js\";\nexport type { SimpleNodeSchemaBase } from \"./simpleNodeSchemaBase.js\";\nexport {\n\ttype StoredSchemaGenerationOptions,\n\tconvertAllowedTypes,\n\tallowedTypeFilter,\n} from \"./toStored.js\";\n"]}
1	+ {"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,yDAY6B;AAX5B,+GAAA,UAAU,OAAA;AACV,mHAAA,cAAc,OAAA;AACd,8GAAA,SAAS,OAAA;AACT,yHAAA,oBAAoB,OAAA;AAEpB,uHAAA,kBAAkB,OAAA;AAClB,iHAAA,YAAY,OAAA;AACZ,uHAAA,kBAAkB,OAAA;AAClB,qIAAA,gCAAgC,OAAA;AAChC,sHAAA,iBAAiB,OAAA;AACjB,2HAAA,sBAAsB,OAAA;AAEvB,6CAKuB;AAHtB,6GAAA,cAAc,OAAA;AACd,+GAAA,gBAAgB,OAAA;AAChB,kHAAA,mBAAmB,OAAA;AAMpB,6CAIuB;AAHtB,uGAAA,QAAQ,OAAA;AACR,2GAAA,YAAY,OAAA;AACZ,+GAAA,gBAAgB,OAAA;AAEjB,yDAM6B;AAL5B,6GAAA,QAAQ,OAAA;AACR,0HAAA,qBAAqB,OAAA;AACrB,sHAAA,iBAAiB,OAAA;AACjB,iIAAA,4BAA4B,OAAA;AAC5B,uHAAA,kBAAkB,OAAA;AAkBnB,qDAY2B;AAX1B,0HAAA,uBAAuB,OAAA;AACvB,yHAAA,sBAAsB,OAAA;AACtB,wHAAA,qBAAqB,OAAA;AACrB,4IAAA,yCAAyC,OAAA;AACzC,kIAAA,+BAA+B,OAAA;AAC/B,wHAAA,qBAAqB,OAAA;AACrB,qHAAA,kBAAkB,OAAA;AAClB,sHAAA,mBAAmB,OAAA;AACnB,gIAAA,6BAA6B,OAAA;AAC7B,gIAAA,6BAA6B,OAAA;AAC7B,gHAAA,aAAa,OAAA;AAqBd,iDAAuF;AAA9E,iHAAA,gBAAgB,OAAA;AAAE,+GAAA,cAAc,OAAA;AACzC,2CAAwD;AAA/C,qGAAA,OAAO,OAAA;AAAE,6GAAA,eAAe,OAAA;AACjC,2DAG8B;AAF7B,kIAAA,4BAA4B,OAAA;AAC5B,yIAAA,mCAAmC,OAAA;AAEpC,iEAMiC;AALhC,gIAAA,uBAAuB,OAAA;AACvB,+HAAA,sBAAsB,OAAA;AACtB,gIAAA,uBAAuB,OAAA;AACvB,0HAAA,iBAAiB,OAAA;AACjB,oHAAA,WAAW,OAAA;AAQZ,6CAAuC;AAA9B,qGAAA,MAAM,OAAA;AACf,uDAK4B;AAJ3B,iHAAA,aAAa,OAAA;AAEb,mIAAA,+BAA+B,OAAA;AAC/B,sHAAA,kBAAkB,OAAA;AAGnB,6CAMuB;AAJtB,kHAAA,mBAAmB,OAAA;AACnB,gHAAA,iBAAiB,OAAA;AAEjB,2GAAA,YAAY,OAAA","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tisTreeNode,\n\tTreeNodeKernel,\n\tgetKernel,\n\ttryGetTreeNodeSchema,\n\ttype InnerNode,\n\ttryDisposeTreeNode,\n\tgetInnerNode,\n\ttreeNodeFromAnchor,\n\tgetSimpleNodeSchemaFromInnerNode,\n\tSimpleContextSlot,\n\twithBufferedTreeEvents,\n} from \"./treeNodeKernel.js\";\nexport {\n\ttype WithType,\n\ttypeNameSymbol,\n\ttypeSchemaSymbol,\n\tcontentSchemaSymbol,\n} from \"./withType.js\";\nexport {\n\ttype Unhydrated,\n\ttype InternalTreeNode,\n} from \"./types.js\";\nexport {\n\tTreeNode,\n\tprivateToken,\n\tinPrototypeChain,\n} from \"./treeNode.js\";\nexport {\n\tNodeKind,\n\tisTreeNodeSchemaClass,\n\tprivateDataSymbol,\n\tgetTreeNodeSchemaPrivateData,\n\tCompatibilityLevel,\n} from \"./treeNodeSchema.js\";\nexport type {\n\tTreeNodeSchema,\n\tTreeNodeSchemaClass,\n\tTreeNodeSchemaNonClass,\n\tTreeNodeSchemaCore,\n\tTreeNodeSchemaBoth,\n\tNodeSchemaMetadata,\n\tTreeLeafValue,\n\tInsertableTypedNode,\n\tNodeBuilderData,\n\tNodeFromSchema,\n\tTreeNodeSchemaCorePrivate,\n\tTreeNodeSchemaPrivateData,\n\tTreeNodeSchemaInitializedData,\n\tFlexContent,\n} from \"./treeNodeSchema.js\";\nexport {\n\tisAnnotatedAllowedTypes,\n\tisAnnotatedAllowedType,\n\tnormalizeAllowedTypes,\n\tnormalizeAndEvaluateAnnotatedAllowedTypes,\n\tnormalizeToAnnotatedAllowedType,\n\tmarkSchemaMostDerived,\n\tevaluateLazySchema,\n\tcreateSchemaUpgrade,\n\tAnnotatedAllowedTypesInternal,\n\tnormalizeAllowedTypesInternal,\n\tSchemaUpgrade,\n} from \"./allowedTypes.js\";\nexport type {\n\tAnnotatedAllowedType,\n\tAllowedTypesFullEvaluated,\n\tImplicitAllowedTypes,\n\tAllowedTypesMetadata,\n\tAllowedTypes,\n\tTreeNodeFromImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tInsertableTreeNodeFromAllowedTypes,\n\tInput,\n\tUnannotateAllowedTypesList,\n\tAllowedTypeMetadata,\n\tAnnotatedAllowedTypes,\n\tAnnotateAllowedTypesList,\n\tAllowedTypesFullInternal,\n\tAllowedTypesFull,\n\tAllowedTypesFullFromMixed,\n\tNumberKeys,\n} from \"./allowedTypes.js\";\nexport { walkAllowedTypes, walkNodeSchema, type SchemaVisitor } from \"./walkSchema.js\";\nexport { Context, HydratedContext } from \"./context.js\";\nexport {\n\tgetOrCreateNodeFromInnerNode,\n\tgetOrCreateNodeFromInnerUnboxedNode,\n} from \"./getOrCreateNode.js\";\nexport {\n\tUnhydratedFlexTreeField,\n\tUnhydratedFlexTreeNode,\n\tUnhydratedSequenceField,\n\tUnhydratedContext,\n\tcreateField,\n} from \"./unhydratedFlexTree.js\";\nexport type {\n\tLazyItem,\n\tFlexList,\n\tFlexListToUnion,\n\tExtractItemType,\n} from \"./flexList.js\";\nexport { isLazy } from \"./flexList.js\";\nexport {\n\tTreeNodeValid,\n\ttype MostDerivedData,\n\tcreateTreeNodeSchemaPrivateData,\n\tisClassBasedSchema,\n} from \"./treeNodeValid.js\";\nexport type { SimpleNodeSchemaBase } from \"./simpleNodeSchemaBase.js\";\nexport {\n\ttype StoredSchemaGenerationOptions,\n\tconvertAllowedTypes,\n\tallowedTypeFilter,\n\ttype StoredFromViewSchemaGenerationOptions,\n\tExpectStored,\n} from \"./toStored.js\";\n"]}

package/dist/simple-tree/core/toStored.d.ts CHANGED Viewed

@@ -2,12 +2,13 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { type AnnotatedAllowedType, type ImplicitAllowedTypes, type SchemaUpgrade } from "./allowedTypes.js";
+import type { SchemaUpgrade } from "./allowedTypes.js";
 import type { TreeTypeSet } from "../../core/index.js";
+import type { SimpleAllowedTypeAttributes, SimpleAllowedTypes } from "../simpleSchema.js";
 /**
  * Options for generating a {@link TreeStoredSchema} from view schema.
  */
-export interface StoredSchemaGenerationOptions {
+export interface StoredFromViewSchemaGenerationOptions {
     /**
      * Determines whether to include staged schema in the resulting stored schema.
      * @remarks
@@ -15,18 +16,24 @@ export interface StoredSchemaGenerationOptions {
      */
     includeStaged(upgrade: SchemaUpgrade): boolean;
 }
+/**
+ * Marker type indicating that the input schema is already a stored schema.
+ */
+export declare const ExpectStored: unique symbol;
+export type ExpectStored = typeof ExpectStored;
+export type StoredSchemaGenerationOptions = StoredFromViewSchemaGenerationOptions | ExpectStored;
 /**
  * Filters an allowed type based on the provided options.
  * @param allowedType - The allowed type to filter.
  * @param options - The options to use for filtering.
  * @returns Whether the allowed type passes the filter.
  */
-export declare function allowedTypeFilter(allowedType: AnnotatedAllowedType, options: StoredSchemaGenerationOptions): boolean;
+export declare function allowedTypeFilter(data: SimpleAllowedTypeAttributes, options: StoredSchemaGenerationOptions): boolean;
 /**
- * Converts an ImplicitAllowedTypes to a stored schema.
+ * Converts a {@link SimpleAllowedTypes} to a stored schema.
  * @param schema - The schema to convert.
  * @param options - The options to use for filtering.
  * @returns The converted stored schema.
  */
-export declare function convertAllowedTypes(schema: ImplicitAllowedTypes, options: StoredSchemaGenerationOptions): TreeTypeSet;
+export declare function convertAllowedTypes(schema: SimpleAllowedTypes, options: StoredSchemaGenerationOptions): TreeTypeSet;
 //# sourceMappingURL=toStored.d.ts.map

package/dist/simple-tree/core/toStored.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"toStored.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,~~EAEN,~~KAAK,~~oBAAoB~~,~~EACzB~~,~~KAAK~~,~~oBAAoB~~,~~EACzB~~,KAAK,~~aAAa~~,~~EAClB~~,MAAM,~~mBAAmB~~,CAAC;~~AAC3B~~,OAAO,KAAK,~~EAA4B~~,~~WAAW~~,EAAE,MAAM,~~qBAAqB~~,CAAC;~~AAEjF~~;;GAEG;AACH,MAAM,WAAW,~~6BAA6B~~;~~IAC7C~~;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;CAC/C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,~~WAAW~~,EAAE,~~oBAAoB~~,EACjC,OAAO,EAAE,6BAA6B,GACpC,OAAO,~~CAMT~~;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,~~oBAAoB~~,~~EAC5B~~,OAAO,EAAE,6BAA6B,GACpC,WAAW,~~CAOb~~"}
1	+ {"version":3,"file":"toStored.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAA4B,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG1F;;GAEG;AACH,MAAM,WAAW,qCAAqC;IACrD;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;CAC/C;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,eAAyB,CAAC;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAE/C,MAAM,MAAM,6BAA6B,GACtC,qCAAqC,GACrC,YAAY,CAAC;AAEhB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,2BAA2B,EACjC,OAAO,EAAE,6BAA6B,GACpC,OAAO,CAsBT;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,6BAA6B,GACpC,WAAW,CAQb"}

package/dist/simple-tree/core/toStored.js CHANGED Viewed

@@ -4,33 +4,49 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertAllowedTypes = exports.allowedTypeFilter = void 0;
+exports.convertAllowedTypes = exports.allowedTypeFilter = exports.ExpectStored = void 0;
 const index_js_1 = require("../../util/index.js");
-const allowedTypes_js_1 = require("./allowedTypes.js");
+const internal_1 = require("@fluidframework/telemetry-utils/internal");
+/**
+ * Marker type indicating that the input schema is already a stored schema.
+ */
+exports.ExpectStored = Symbol("ExpectStored");
 /**
  * Filters an allowed type based on the provided options.
  * @param allowedType - The allowed type to filter.
  * @param options - The options to use for filtering.
  * @returns Whether the allowed type passes the filter.
  */
-function allowedTypeFilter(allowedType, options) {
+function allowedTypeFilter(data, options) {
+    if (options === exports.ExpectStored) {
+        if (data.isStaged !== undefined) {
+            throw new internal_1.UsageError("Failed to covert view schema to stored schema. The simple schema provided was indicated to be a stored schema by the use of `ExpectStored`, but view schema specific content was encountered which requires a `StoredFromViewSchemaGenerationOptions` to process.");
+        }
+        return true;
+    }
+    if (data.isStaged === undefined) {
+        throw new internal_1.UsageError("Failed to covert view schema to stored schema. The simple schema provided as the view schema was actually a stored schema. If this was intended, use `ExpectStored` for the `StoredSchemaGenerationOptions` to indicate the input is already a stored schema and only a format conversion is required.");
+    }
     // If the allowed type is staged, only include it if the options allow it.
-    if (allowedType.metadata.stagedSchemaUpgrade !== undefined) {
-        return options.includeStaged(allowedType.metadata.stagedSchemaUpgrade);
+    if (data.isStaged === false) {
+        return true;
     }
-    return true;
+    return options.includeStaged(data.isStaged);
 }
 exports.allowedTypeFilter = allowedTypeFilter;
 /**
- * Converts an ImplicitAllowedTypes to a stored schema.
+ * Converts a {@link SimpleAllowedTypes} to a stored schema.
  * @param schema - The schema to convert.
  * @param options - The options to use for filtering.
  * @returns The converted stored schema.
  */
 function convertAllowedTypes(schema, options) {
-    const filtered = (0, allowedTypes_js_1.normalizeAndEvaluateAnnotatedAllowedTypes)(schema)
-        .types.filter((allowedType) => allowedTypeFilter(allowedType, options))
-        .map((a) => (0, index_js_1.brand)(a.type.identifier));
+    const filtered = [];
+    for (const [type, data] of schema) {
+        if (allowedTypeFilter(data, options)) {
+            filtered.push((0, index_js_1.brand)(type));
+        }
+    }
     return new Set(filtered);
 }
 exports.convertAllowedTypes = convertAllowedTypes;

package/dist/simple-tree/core/toStored.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"toStored.js","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kDAA4C;~~AAC5C~~,~~uDAK2B~~;~~AAe3B~~;;;;;GAKG;AACH,SAAgB,iBAAiB,CAChC,~~WAAiC~~,EACjC,OAAsC;IAEtC,~~0EAA0E~~;~~IAC1E~~,IAAI,~~WAAW~~,CAAC,QAAQ,CAAC,~~mBAAmB~~,KAAK,SAAS,EAAE,CAAC;~~QAC5D~~,~~OAAO~~,~~OAAO~~,~~CAAC~~,~~aAAa~~,CAAC,~~WAAW~~,CAAC,QAAQ,~~CAAC~~,~~mBAAmB~~,CAAC,CAAC;~~IACxE~~,CAAC;~~IACD~~,OAAO,IAAI,CAAC;~~AACb~~,CAAC;~~AATD~~,~~8CASC~~;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAClC,~~MAA4B~~,~~EAC5B~~,OAAsC;IAEtC,MAAM,QAAQ,GAA+B,~~IAAA~~,~~2DAAyC~~,~~EACrF~~,MAAM,~~CACN;SACC~~,~~KAAK~~,~~CAAC~~,~~MAAM~~,CAAC,~~CAAC~~,~~WAAW~~,EAAE,~~EAAE,~~CAAC,iBAAiB,CAAC,~~WAAW~~,EAAE,OAAO,CAAC,CAAC;~~SACtE~~,~~GAAG~~,CAAC,~~CAAC~~,CAAC,~~EAAE,EAAE,CAAC,~~IAAA,gBAAK,~~EAAC~~,~~CAAC~~,CAAC,~~IAAI,~~CAAC,~~UAAU,~~CAAC,CAAC,CAAC;~~IACvC~~,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC;~~AAVD~~,~~kDAUC~~","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { brand } from \"../../util/index.js\";\nimport {~~\n\tnormalizeAndEvaluateAnnotatedAllowedTypes,\n\ttype~~ ~~AnnotatedAllowedType,\n\ttype~~ ~~ImplicitAllowedTypes,\n\ttype SchemaUpgrade,\n~~} from \"./allowedTypes.js\";\nimport type { TreeNodeSchemaIdentifier, TreeTypeSet } from \"../../core/index.js\";\n\n/\n Options for generating a {@link TreeStoredSchema} from view schema.\n /\nexport interface ~~StoredSchemaGenerationOptions~~ {\n\t/\n\t Determines whether to include staged schema in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t /\n\tincludeStaged(upgrade: SchemaUpgrade): boolean;\n}\n\n/\n Filters an allowed type based on the provided options.\n * @param allowedType - The allowed type to filter.\n * @param options - The options to use for filtering.\n * @returns Whether the allowed type passes the filter.\n /\nexport function allowedTypeFilter(\n\~~tallowedType~~: ~~AnnotatedAllowedType~~,\n\toptions: StoredSchemaGenerationOptions,\n): boolean {\n\t// If the allowed type is staged, only include it if the options allow it.\n\tif (~~allowedType~~.~~metadata.stagedSchemaUpgrade~~ ~~!==~~ ~~undefined~~) {\n\t\treturn ~~options.includeStaged(allowedType.metadata.stagedSchemaUpgrade)~~;\n\t}\n\treturn ~~true~~;\n}\n\n/\n Converts an ~~ImplicitAllowedTypes~~ to a stored schema.\n * @param schema - The schema to convert.\n * @param options - The options to use for filtering.\n * @returns The converted stored schema.\n */\nexport function convertAllowedTypes(\n\tschema: ~~ImplicitAllowedTypes~~,\n\toptions: StoredSchemaGenerationOptions,\n): TreeTypeSet {\n\tconst filtered: TreeNodeSchemaIdentifier[] = ~~normalizeAndEvaluateAnnotatedAllowedTypes(\~~n\~~t\tschema,\n\t~~)\n\t\~~t.types.filter~~(~~(allowedType) =>~~ allowedTypeFilter(~~allowedType~~, options))\n\t\t.~~map~~(~~(a) =>~~ brand(a.type~~.identifier~~));\n\treturn new Set(filtered);\n}\n"]}
1	+ {"version":3,"file":"toStored.js","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kDAA4C;AAI5C,uEAAsE;AActE;;GAEG;AACU,QAAA,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAOnD;;;;;GAKG;AACH,SAAgB,iBAAiB,CAChC,IAAiC,EACjC,OAAsC;IAEtC,IAAI,OAAO,KAAK,oBAAY,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,IAAI,qBAAU,CACnB,mQAAmQ,CACnQ,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,qBAAU,CACnB,wSAAwS,CACxS,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC7C,CAAC;AAzBD,8CAyBC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAClC,MAA0B,EAC1B,OAAsC;IAEtC,MAAM,QAAQ,GAA+B,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,EAAE,CAAC;QACnC,IAAI,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;YACtC,QAAQ,CAAC,IAAI,CAAC,IAAA,gBAAK,EAA2B,IAAI,CAAC,CAAC,CAAC;QACtD,CAAC;IACF,CAAC;IACD,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC;AAXD,kDAWC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { brand } from \"../../util/index.js\";\nimport type { SchemaUpgrade } from \"./allowedTypes.js\";\nimport type { TreeNodeSchemaIdentifier, TreeTypeSet } from \"../../core/index.js\";\nimport type { SimpleAllowedTypeAttributes, SimpleAllowedTypes } from \"../simpleSchema.js\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\n/\n Options for generating a {@link TreeStoredSchema} from view schema.\n /\nexport interface StoredFromViewSchemaGenerationOptions {\n\t/\n\t Determines whether to include staged schema in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t /\n\tincludeStaged(upgrade: SchemaUpgrade): boolean;\n}\n\n/\n Marker type indicating that the input schema is already a stored schema.\n /\nexport const ExpectStored = Symbol(\"ExpectStored\");\nexport type ExpectStored = typeof ExpectStored;\n\nexport type StoredSchemaGenerationOptions =\n\t\| StoredFromViewSchemaGenerationOptions\n\t\| ExpectStored;\n\n/\n Filters an allowed type based on the provided options.\n * @param allowedType - The allowed type to filter.\n * @param options - The options to use for filtering.\n * @returns Whether the allowed type passes the filter.\n /\nexport function allowedTypeFilter(\n\tdata: SimpleAllowedTypeAttributes,\n\toptions: StoredSchemaGenerationOptions,\n): boolean {\n\tif (options === ExpectStored) {\n\t\tif (data.isStaged !== undefined) {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"Failed to covert view schema to stored schema. The simple schema provided was indicated to be a stored schema by the use of `ExpectStored`, but view schema specific content was encountered which requires a `StoredFromViewSchemaGenerationOptions` to process.\",\n\t\t\t);\n\t\t}\n\t\treturn true;\n\t}\n\n\tif (data.isStaged === undefined) {\n\t\tthrow new UsageError(\n\t\t\t\"Failed to covert view schema to stored schema. The simple schema provided as the view schema was actually a stored schema. If this was intended, use `ExpectStored` for the `StoredSchemaGenerationOptions` to indicate the input is already a stored schema and only a format conversion is required.\",\n\t\t);\n\t}\n\n\t// If the allowed type is staged, only include it if the options allow it.\n\tif (data.isStaged === false) {\n\t\treturn true;\n\t}\n\n\treturn options.includeStaged(data.isStaged);\n}\n\n/\n Converts a {@link SimpleAllowedTypes} to a stored schema.\n * @param schema - The schema to convert.\n * @param options - The options to use for filtering.\n * @returns The converted stored schema.\n */\nexport function convertAllowedTypes(\n\tschema: SimpleAllowedTypes,\n\toptions: StoredSchemaGenerationOptions,\n): TreeTypeSet {\n\tconst filtered: TreeNodeSchemaIdentifier[] = [];\n\tfor (const [type, data] of schema) {\n\t\tif (allowedTypeFilter(data, options)) {\n\t\t\tfiltered.push(brand<TreeNodeSchemaIdentifier>(type));\n\t\t}\n\t}\n\treturn new Set(filtered);\n}\n"]}

package/dist/simple-tree/core/treeNodeSchema.d.ts CHANGED Viewed

@@ -9,10 +9,9 @@ import type { InternalTreeNode, Unhydrated } from "./types.js";
 import type { UnionToIntersection } from "../../util/index.js";
 import type { AllowedTypesFullEvaluated, AllowedTypesFull } from "./allowedTypes.js";
 import type { Context } from "./context.js";
-import type { FieldKey, NodeData, TreeNodeStoredSchema } from "../../core/index.js";
+import type { FieldKey, NodeData } from "../../core/index.js";
 import type { UnhydratedFlexTreeField } from "./unhydratedFlexTree.js";
 import type { FactoryContent } from "../unhydratedFlexTreeFromInsertable.js";
-import type { StoredSchemaGenerationOptions } from "./toStored.js";
 /**
  * Schema for a {@link TreeNode} or {@link TreeLeafValue}.
  *
@@ -252,10 +251,6 @@ export interface TreeNodeSchemaPrivateData {
      * Idempotent initialization function that pre-caches data and can dereference lazy schema references.
      */
     idempotentInitialize(): TreeNodeSchemaInitializedData;
-    /**
-     * Converts a the schema into a {@link TreeNodeStoredSchema}.
-     */
-    toStored(options: StoredSchemaGenerationOptions): TreeNodeStoredSchema;
 }
 /**
  * Additional data about a given schema which is private to this package.

package/dist/simple-tree/core/treeNodeSchema.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"treeNodeSchema.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,~~oBAAoB,EAAE,~~MAAM,qBAAqB,CAAC;~~AACpF~~,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;~~AAC7E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAEnE~~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~~IAEtD;;OAEG~~;~~IACH,QAAQ,CAAC,OAAO,EAAE,6BAA6B,GAAG,oBAAoB,CAAC;CACvE;~~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"}
1	+ {"version":3,"file":"treeNodeSchema.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,cAAc,CACzB,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,KAAK,SAAS,QAAQ,GAAG,aAAa,GAAG,QAAQ,GAAG,aAAa,EACjE,MAAM,GAAG,KAAK,EACd,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,EACd,eAAe,GAAG,OAAO,IAEvB,CAAC,KAAK,SAAS,QAAQ,GACrB,mBAAmB,CACnB,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,MAAM,EACN,uBAAuB,EACvB,IAAI,EACJ,KAAK,EACL,eAAe,CACf,GACA,KAAK,CAAC,GACR,sBAAsB,CACtB,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,MAAM,EACN,uBAAuB,EACvB,IAAI,EACJ,KAAK,EACL,eAAe,CACd,CAAC;AAEL;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,CACjC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,KAAK,SAAS,QAAQ,GAAG,aAAa,GAAG,QAAQ,GAAG,aAAa,EACjE,WAAW,GAAG,KAAK,EACnB,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,EACd,iBAAiB,GAAG,KAAK,EACzB,eAAe,GAAG,OAAO,IACtB,kBAAkB,CACrB,IAAI,EACJ,IAAI,EACJ,uBAAuB,EACvB,IAAI,EACJ,WAAW,EACX,eAAe,CACf,GACA,CAAC,SAAS,SAAS,iBAAiB,GACjC;IACA;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,iBAAiB,GAAG,KAAK,CAAC;CACtD,GACA;IACA;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,GAAG,KAAK,CAAC;CACrD,CAAC,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,MAAM,mBAAmB,CAC9B,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,KAAK,SAAS,QAAQ,GAAG,QAAQ,EACjC,WAAW,GAAG,KAAK,EACnB,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,EACd,iBAAiB,GAAG,KAAK,EACzB,eAAe,GAAG,OAAO,IACtB,kBAAkB,CACrB,IAAI,EACJ,IAAI,EACJ,uBAAuB,EACvB,IAAI,EACJ,WAAW,EACX,eAAe,CACf,GACA,CAAC,SAAS,SAAS,iBAAiB,GACjC;IACA;;;;;;OAMG;IAGH,KAAK,IAAI,CAAC,EAAE,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CACnF,GACA;IACA;;;;;;OAMG;IAGH,KAAK,IAAI,EAAE,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CAClF,CAAC,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAC7B,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,KAAK,SAAS,QAAQ,GAAG,QAAQ,EACjC,WAAW,GAAG,KAAK,EACnB,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,EACd,iBAAiB,GAAG,KAAK,EACzB,eAAe,GAAG,OAAO,IACtB,mBAAmB,CACtB,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,WAAW,EACX,uBAAuB,EACvB,IAAI,EACJ,iBAAiB,EACjB,eAAe,CACf,GACA,sBAAsB,CACrB,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,WAAW,EACX,uBAAuB,EACvB,IAAI,EACJ,iBAAiB,EACjB,eAAe,CACf,CAAC;AAEH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB,CAClC,GAAG,CAAC,IAAI,SAAS,MAAM,EACvB,GAAG,CAAC,IAAI,SAAS,QAAQ,EACzB,GAAG,CAAC,uBAAuB,SAAS,OAAO,EAC3C,GAAG,CAAC,IAAI,GAAG,OAAO,EAClB,GAAG,CAAC,WAAW,GAAG,KAAK,EACvB,GAAG,CAAC,eAAe,GAAG,OAAO,CAC5B,SAAQ,oBAAoB,CAAC,IAAI,EAAE,eAAe,CAAC;IACpD;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAE1B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAEpB;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,EAAE,uBAAuB,CAAC;IAE1D;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IAEjD;;;;;;;;;;;;;;;OAeG;IACH,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC,QAAQ,GAAG,aAAa,CAAC,CAAC;CAC9E;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAwB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,yBAAyB,CACzC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,WAAW,GAAG,KAAK,EACnB,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,EACd,eAAe,GAAG,OAAO,CACxB,SAAQ,kBAAkB,CAC1B,IAAI,EACJ,IAAI,EACJ,uBAAuB,EACvB,IAAI,EACJ,WAAW,EACX,eAAe,CACf;IACD;;;;;;;;;OASG;IACH,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,yBAAyB,CAAC;CACxD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACzC;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAExD;;OAEG;IACH,oBAAoB,IAAI,6BAA6B,CAAC;CACtD;AAED;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC7C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,iBAAiB,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAEjE;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;;;;OAMG;IACH,wBAAwB,CAAC,IAAI,EAAE,cAAc,GAAG,kBAAkB,CAAC;IAEnE;;;;;;;OAOG;IACH,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,GAAG,WAAW,CAAC;CAC5F;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,uBAAuB,CAAC,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;GAeG;AACH,oBAAY,kBAAkB;IAC7B;;OAEG;IACH,IAAI,IAAI;IACR;;OAEG;IACH,GAAG,IAAI;IACP;;OAEG;IACH,MAAM,IAAI;CACV;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,GACnD,yBAAyB,CAO3B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IACnB;;OAEG;IACH,GAAG,IAAI;IACP;;OAEG;IACH,KAAK,IAAI;IACT;;;;OAIG;IACH,MAAM,IAAI;IACV;;OAEG;IACH,IAAI,IAAI;IACR;;OAEG;IACH,MAAM,IAAI;CACV;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,GAAG,CAAC,eAAe,GAAG,OAAO;IAChE;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IAE9C;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,SAAS,MAAM,EACnB,IAAI,SAAS,QAAQ,EACrB,KAAK,SAAS,QAAQ,GAAG,aAAa,EACtC,MAAM,EACN,uBAAuB,SAAS,OAAO,EACvC,IAAI,EAEJ,MAAM,EACH,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,IAAI,CAAC,GACxE,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,GAAG,QAAQ,EAAE,MAAM,EAAE,uBAAuB,EAAE,IAAI,CAAC,GACzF,MAAM,IAAI,mBAAmB,CAC/B,IAAI,EACJ,IAAI,EACJ,KAAK,GAAG,QAAQ,EAChB,MAAM,EACN,uBAAuB,EACvB,IAAI,CACJ,CAEA;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,SAAS,mBAAmB,CACnF,MAAM,EACN,QAAQ,EACR,MAAM,KAAK,CACX,GACE,KAAK,GACL,CAAC,SAAS,sBAAsB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC,GAC9D,KAAK,GACL,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,mBAAmB,CAC9B,OAAO,SAAS,cAAc,EAC9B,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,IAE9B,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,aAAa,EAAE,KAAK,EAAE,IAAI,CAAC,GAChF,eAAe,CAAC,CAAC,CAAC,GAClB,KAAK,CAAC,GACR,CAAC,CAAC,SAAS,cAAc,GACvB,UAAU,CAAC,QAAQ,SAAS,cAAc,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,GAC1E,KAAK,CAAC,CAAC;AAEZ;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,IAClF,CAAC,SAAS,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC,GAC3E,MAAM,GACN,KAAK,CAAC;AAEV;;;;;GAKG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,IAAI,CAAC"}

package/dist/simple-tree/core/treeNodeSchema.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"treeNodeSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAsU7D;;GAEG;AACU,QAAA,iBAAiB,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AAkHvD;;;;;;;;;;;;;;;GAeG;AACH,IAAY,kBAaX;AAbD,WAAY,kBAAkB;IAC7B;;OAEG;IACH,2DAAQ,CAAA;IACR;;OAEG;IACH,yDAAO,CAAA;IACP;;OAEG;IACH,+DAAU,CAAA;AACX,CAAC,EAbW,kBAAkB,kCAAlB,kBAAkB,QAa7B;AAED;;GAEG;AACH,SAAgB,4BAA4B,CAC3C,MAAqD;IAErD,IAAA,iBAAM,EACL,yBAAiB,IAAI,MAAM,EAC3B,KAAK,CAAC,6FAA6F,CACnG,CAAC;IACF,MAAM,WAAW,GAAG,MAAmC,CAAC;IACxD,OAAO,WAAW,CAAC,yBAAiB,CAAC,CAAC;AACvC,CAAC;AATD,oEASC;AAED;;;;;GAKG;AACH,IAAY,QAuBX;AAvBD,WAAY,QAAQ;IACnB;;OAEG;IACH,qCAAO,CAAA;IACP;;OAEG;IACH,yCAAS,CAAA;IACT;;;;OAIG;IACH,2CAAU,CAAA;IACV;;OAEG;IACH,uCAAQ,CAAA;IACR;;OAEG;IACH,2CAAU,CAAA;AACX,CAAC,EAvBW,QAAQ,wBAAR,QAAQ,QAuBnB;AA4BD;;;GAGG;AACH,SAAgB,qBAAqB,CAQpC,MAE2F;IAS3F,OAAO,MAAM,CAAC,WAAW,KAAK,SAAS,CAAC;AACzC,CAAC;AApBD,sDAoBC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\n\nimport type { SimpleNodeSchemaBase } from \"./simpleNodeSchemaBase.js\";\nimport type { TreeNode } from \"./treeNode.js\";\nimport type { InternalTreeNode, Unhydrated } from \"./types.js\";\nimport type { UnionToIntersection } from \"../../util/index.js\";\nimport type { AllowedTypesFullEvaluated, AllowedTypesFull } from \"./allowedTypes.js\";\nimport type { Context } from \"./context.js\";\nimport type { FieldKey, NodeData, TreeNodeStoredSchema } from \"../../core/index.js\";\nimport type { UnhydratedFlexTreeField } from \"./unhydratedFlexTree.js\";\nimport type { FactoryContent } from \"../unhydratedFlexTreeFromInsertable.js\";\nimport type { StoredSchemaGenerationOptions } from \"./toStored.js\";\n\n/\n Schema for a {@link TreeNode} or {@link TreeLeafValue}.\n \n @typeParam Name - The full (including scope) name/identifier for the schema.\n * @typeParam Kind - Which kind of node this schema is for.\n * @typeParam TNode - API for nodes that use this schema.\n * @typeParam TBuild - Data which can be used to construct an {@link Unhydrated} node of this type.\n * @typeParam Info - Data used when defining this schema.\n * @remarks\n * Captures the schema both as runtime data and compile time type information.\n * Use {@link SchemaFactory} to define schema.\n * Use `Tree.schema(value)` to lookup the schema for a {@link TreeNode} or {@link TreeLeafValue}.\n * @privateRemarks\n * TODO:\n * The long lists of type parameters here are awkward to deal with.\n * Switching to (or adding an option to use)\n * an interface based pattern with unordered named parameters for types like this would be a good idea.\n * The related `@system` types should be simple to port to the new pattern, but stable public one like this will need to support both:\n * the new one could either be added as a system type, or be recommended to replace this one (deprecating it).\n * @sealed @public\n /\nexport type TreeNodeSchema<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue = TreeNode \| TreeLeafValue,\n\tTBuild = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTCustomMetadata = unknown,\n> =\n\t\| (TNode extends TreeNode\n\t\t\t? TreeNodeSchemaClass<\n\t\t\t\t\tName,\n\t\t\t\t\tKind,\n\t\t\t\t\tTNode,\n\t\t\t\t\tTBuild,\n\t\t\t\t\tImplicitlyConstructable,\n\t\t\t\t\tInfo,\n\t\t\t\t\tnever,\n\t\t\t\t\tTCustomMetadata\n\t\t\t\t>\n\t\t\t: never)\n\t\| TreeNodeSchemaNonClass<\n\t\t\tName,\n\t\t\tKind,\n\t\t\tTNode,\n\t\t\tTBuild,\n\t\t\tImplicitlyConstructable,\n\t\t\tInfo,\n\t\t\tnever,\n\t\t\tTCustomMetadata\n\t >;\n\n/\n Schema which is not a class.\n * @remarks\n * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.\n * @privateRemarks\n * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.\n * @system @sealed @public\n /\nexport type TreeNodeSchemaNonClass<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue = TreeNode \| TreeLeafValue,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaCore<\n\tName,\n\tKind,\n\tImplicitlyConstructable,\n\tInfo,\n\tTInsertable,\n\tTCustomMetadata\n> &\n\t(undefined extends TConstructorExtra\n\t\t? {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Also allows InternalTreeNode.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\tcreate(data?: TInsertable \| TConstructorExtra): TNode;\n\t\t\t}\n\t\t: {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Also allows InternalTreeNode.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\tcreate(data: TInsertable \| TConstructorExtra): TNode;\n\t\t\t});\n\n/\n Tree node schema which is implemented using a class.\n * @remarks\n * Instances of this class are nodes in the tree.\n * This is also a constructor so that it can be subclassed.\n \n Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.\n * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer \"any\" in the d.ts file.\n \n When sub-classing a a `TreeNodeSchemaClass`, some extra rules must be followed:\n \n - Only ever use a single class from the schema's class hierarchy within a document and its schema.\n * For example, if using {@link SchemaFactory.object} you can do:\n * ```typescript\n * // Recommended \"customizable\" object schema pattern.\n * class Good extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \tpublic exampleCustomMethod(): void {\n * \t\tthis.exampleField++;\n * \t}\n * }\n * ```\n * But should avoid:\n * ```typescript\n * // This by itself is ok, and opts into \"POJO mode\".\n * const base = schemaFactory.object(\"A\", {});\n * // This is a bad pattern since it leaves two classes in scope which derive from the same SchemaFactory defined class.\n * // If both get used, its an error!\n * class Invalid extends base {}\n * ```\n \n - Do not modify the constructor input parameter types or values:\n * ```typescript\n * class Invalid extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \t// This Modifies the type of the constructor input.\n * \t// This is unsupported due to programmatic access to the constructor being used internally.\n * \tpublic constructor(a: number) {\n * \t\tsuper({ exampleField: a });\n * \t}\n * }\n * ```\n * @sealed @public\n /\nexport type TreeNodeSchemaClass<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode = TreeNode,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaCore<\n\tName,\n\tKind,\n\tImplicitlyConstructable,\n\tInfo,\n\tTInsertable,\n\tTCustomMetadata\n> &\n\t(undefined extends TConstructorExtra\n\t\t? {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @remarks\n\t\t\t\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t\t\t\t * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\t// The approach suggested by the linter here is more concise, but ir break intellisense for the constructor.\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t\t\t\tnew (data?: TInsertable \| InternalTreeNode \| TConstructorExtra): Unhydrated<TNode>;\n\t\t\t}\n\t\t: {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @remarks\n\t\t\t\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t\t\t\t * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\t// The approach suggested by the linter here is more concise, but ir break intellisense for the constructor.\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t\t\t\tnew (data: TInsertable \| InternalTreeNode \| TConstructorExtra): Unhydrated<TNode>;\n\t\t\t});\n\n/\n Internal helper for utilities that return schema which can be used in class and non class formats depending on the API exposing it.\n /\nexport type TreeNodeSchemaBoth<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode = TreeNode,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaClass<\n\tName,\n\tKind,\n\tTNode,\n\tTInsertable,\n\tImplicitlyConstructable,\n\tInfo,\n\tTConstructorExtra,\n\tTCustomMetadata\n> &\n\tTreeNodeSchemaNonClass<\n\t\tName,\n\t\tKind,\n\t\tTNode,\n\t\tTInsertable,\n\t\tImplicitlyConstructable,\n\t\tInfo,\n\t\tTConstructorExtra,\n\t\tTCustomMetadata\n\t>;\n\n/\n Data common to all tree node schema.\n \n @remarks\n * Implementation detail of {@link TreeNodeSchema} which should be accessed instead of referring to this type directly.\n \n @privateRemarks\n * All implementations must implement {@link TreeNodeSchemaCorePrivate} as well.\n \n @sealed @public\n /\nexport interface TreeNodeSchemaCore<\n\tout Name extends string,\n\tout Kind extends NodeKind,\n\tout ImplicitlyConstructable extends boolean,\n\tout Info = unknown,\n\tout TInsertable = never,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBase<Kind, TCustomMetadata> {\n\t/\n\t Unique (within a document's schema) identifier used to associate nodes with their schema.\n\t * @remarks\n\t * This is used when encoding nodes, and when decoding nodes to re-associate them with the schema.\n\t * Since this decoding may happen in a different version of the application (or even a different application altogether),\n\t * this identifier should generally correspond to some specific semantics for the data (how to interpret the node with this identifier).\n\t * Any time the semantics change such that data would be misinterpreted if the old semantics were applied\n\t * (for example the units of a value are changed),\n\t * it is best practice to pick a new identifier.\n\t /\n\treadonly identifier: Name;\n\n\t/\n\t Data used to define this schema.\n\t \n\t @remarks\n\t * The format depends on the kind of node it is for.\n\t * For example, the \"object\" node kind could store the field schema here.\n\t /\n\treadonly info: Info;\n\n\t/\n\t When constructing insertable content,\n\t * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node\n\t * iff implicitlyConstructable is true.\n\t * @privateRemarks\n\t * Currently the logic for traversing insertable content,\n\t * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,\n\t * so if their constructors differ from what is supported, some cases will not work.\n\t * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.\n\t /\n\treadonly implicitlyConstructable: ImplicitlyConstructable;\n\n\t/\n\t All possible schema that a direct child of a node with this schema could have.\n\t \n\t Equivalently, this is also all schema directly referenced when defining this schema's allowed child types,\n\t * which is also the same as the set of schema referenced directly by the `Info` type parameter and the `info` property.\n\t * This property is simply re-exposing that information in an easier to traverse format consistent across all node kinds.\n\t * @remarks\n\t * Some kinds of nodes may have additional restrictions on children:\n\t * this set simply enumerates all directly referenced schema, and can be use to walk over all referenced schema types.\n\t \n\t This set cannot be used before the schema in it have been defined:\n\t * more specifically, when using lazy schema references (for example to make foreword references to schema which have not yet been defined),\n\t * users must wait until after the schema are defined to access this set.\n\t * @privateRemarks\n\t * Currently there isn't much use for this in the public API,\n\t * and it's possible this will want to be tweaked or renamed as part of a larger schema reflection API surface that might be added later.\n\t * To keep options option, this is marked `@system` for now.\n\t * @system\n\t /\n\treadonly childTypes: ReadonlySet<TreeNodeSchema>;\n\n\t/\n\t Constructs an instance of this node type.\n\t * @remarks\n\t * Due to TypeScript limitations, the return type of this method can not be very specific.\n\t * For {@link TreeNodeSchemaClass} prefer using the constructor directly for better typing.\n\t * For {@link TreeNodeSchemaNonClass} use `create`.\n\t \n\t @privateRemarks\n\t * This method signature provides a way to infer `TInsertable` without relying on the constructor, and to construct nodes from schema of unknown kind.\n\t * This makes customizations of the constructor not impact the typing of insertable content, allowing customization of the constructor,\n\t * as long as doing so only adds additional supported cases.\n\t \n\t This cannot be required to return `TNode`:\n\t * doing so breaks sub-classing of schema since they don't overload this method with a more specific return type.\n\t * @sealed @system\n\t /\n\tcreateFromInsertable(data: TInsertable): Unhydrated<TreeNode \| TreeLeafValue>;\n}\n\n/\n Symbol for use by {@link TreeNodeSchemaCorePrivate}.\n /\nexport const privateDataSymbol = Symbol(\"PrivateData\");\n\n/\n {@link TreeNodeSchemaCore} extended with some non-exported APIs.\n /\nexport interface TreeNodeSchemaCorePrivate<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTCustomMetadata = unknown,\n> extends TreeNodeSchemaCore<\n\t\tName,\n\t\tKind,\n\t\tImplicitlyConstructable,\n\t\tInfo,\n\t\tTInsertable,\n\t\tTCustomMetadata\n\t> {\n\t/\n\t Package private data provided by all {@link TreeNodeSchema}.\n\t * @remarks\n\t * Users can add custom statics to schema classes.\n\t * To reduce the risk of such statics colliding with properties used to implement the schema,\n\t * some of the private APIs are grouped together under this symbol.\n\t \n\t Note that there are still some properties which are not under a symbol and thus expose some risk of name collisions.\n\t * See {@link TreeNodeValid} for some such properties.\n\t /\n\treadonly [privateDataSymbol]: TreeNodeSchemaPrivateData;\n}\n\n/\n Package private data provided by all {@link TreeNodeSchema}.\n * @remarks\n * This data needs to be available before lazy schema references are resolved.\n * For data which is only available after lazy schema references are resolved,\n * see {@link TreeNodeSchemaInitializedData}, which can be accessed via {@link TreeNodeSchemaPrivateData.idempotentInitialize}.\n /\nexport interface TreeNodeSchemaPrivateData {\n\t/\n\t All possible annotated allowed types that a field under a node with this schema could have.\n\t * @remarks\n\t * In this case \"field\" includes anything that is a field in the internal (flex-tree) abstraction layer.\n\t * This includes the content field for arrays, and all the fields for map nodes.\n\t * If this node does not have fields (and thus is a leaf), the array will be empty.\n\t * @privateRemarks\n\t * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.\n\t * @system\n\t /\n\treadonly childAllowedTypes: readonly AllowedTypesFull[];\n\n\t/\n\t Idempotent initialization function that pre-caches data and can dereference lazy schema references.\n\t /\n\tidempotentInitialize(): TreeNodeSchemaInitializedData;\n\n\t/\n\t Converts a the schema into a {@link TreeNodeStoredSchema}.\n\t /\n\ttoStored(options: StoredSchemaGenerationOptions): TreeNodeStoredSchema;\n}\n\n/\n Additional data about a given schema which is private to this package.\n * @remarks\n * Created by {@link TreeNodeValid.oneTimeSetup} and can involve dereferencing lazy schema references.\n /\nexport interface TreeNodeSchemaInitializedData {\n\t/\n\t All possible annotated allowed types that a field under a node with this schema could have.\n\t * @remarks\n\t * In this case \"field\" includes anything that is a field in the internal (flex-tree) abstraction layer.\n\t * This includes the content field for arrays, and all the fields for map nodes.\n\t * If this node does not have fields (and thus is a leaf), the array will be empty.\n\t \n\t This set cannot be used before the schema in it have been defined:\n\t * more specifically, when using lazy schema references (for example to make foreword references to schema which have not yet been defined),\n\t * users must wait until after the schema are defined to access this array.\n\t \n\t @privateRemarks\n\t * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.\n\t * @system\n\t /\n\treadonly childAllowedTypes: readonly AllowedTypesFullEvaluated[];\n\n\t/\n\t A {@link Context} which can be used for unhydrated nodes of this schema.\n\t /\n\treadonly context: Context;\n\n\t/\n\t Checks if data might be schema-compatible.\n\t \n\t @returns false if `data` is incompatible with `type` based on a cheap/shallow check.\n\t \n\t Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.\n\t /\n\tshallowCompatibilityTest(data: FactoryContent): CompatibilityLevel;\n\n\t/\n\t Convert data to a {@link FlexContent} representation.\n\t * @remarks\n\t * Data must be compatible with the schema according to {@link shallowCompatibilityTest}.\n\t \n\t TODO: use of `allowedTypes` is for fallbacks (for example NaN -\\> null).\n\t * This behavior should be moved to shallowCompatibilityTest instead.\n\t /\n\ttoFlexContent(data: FactoryContent, allowedTypes: ReadonlySet<TreeNodeSchema>): FlexContent;\n}\n\nexport type FlexContent = [NodeData, Map<FieldKey, UnhydratedFlexTreeField>];\n\n/\n Indicates a compatibility level for inferring a schema to apply to insertable data.\n * @remarks\n * Each schema allowed at a location in the tree has its compatibility level checked against the data being inserted.\n * The compatibility is considered unambiguous if there is a single schema with a higher compatibility than all others.\n \n This approach allows adding new compatible formats as a non breaking change.\n * If the new format was already compatible with some other schema, it can still be added as non-breaking as long as a lower compatibility level is used.\n * For example, support for constructing maps from record like objects was added in Fluid Framework 2.2.\n * This format (an object with fields) was already compatible with Object nodes at compatibility level Normal so the new format support for maps was added at compatibility level Low.\n * This ensures that existing code that was using object literals as insertable content where both objects and maps were allowed will continue to work,\n * assuming the objects are intended as ObjectNodes.\n * However new code can now be written using record like objects to construct maps, as long as the schema does not also allow Object nodes which are compatible with the data in that location.\n \n @see {@link ITreeConfigurationOptions.preventAmbiguity} for a related setting which interacts with this in a somewhat complex way.\n /\nexport enum CompatibilityLevel {\n\t/\n\t Not compatible. Constructor typing indicates incompatibility.\n\t /\n\tNone = 0,\n\t/\n\t Additional compatibility cases added in Fluid Framework 2.2.\n\t /\n\tLow = 1,\n\t/\n\t Compatible in Fluid Framework 2.0.\n\t /\n\tNormal = 2,\n}\n\n/\n Downcasts a {@link TreeNodeSchemaCore} to {@link TreeNodeSchemaCorePrivate} and get its {@link TreeNodeSchemaPrivateData}.\n /\nexport function getTreeNodeSchemaPrivateData(\n\tschema: TreeNodeSchemaCore<string, NodeKind, boolean>,\n): TreeNodeSchemaPrivateData {\n\tassert(\n\t\tprivateDataSymbol in schema,\n\t\t0xbc9 / All implementations of TreeNodeSchemaCore must also implement TreeNodeSchemaCorePrivate /,\n\t);\n\tconst schemaValid = schema as TreeNodeSchemaCorePrivate;\n\treturn schemaValid[privateDataSymbol];\n}\n\n/\n Kind of tree node.\n * @remarks\n * More kinds may be added over time, so do not assume this is an exhaustive set.\n * @public\n /\nexport enum NodeKind {\n\t/\n\t A node which serves as a map, storing children under string keys.\n\t /\n\tMap = 0,\n\t/\n\t A node which serves as an array, storing children in an ordered sequence.\n\t /\n\tArray = 1,\n\t/\n\t A node which stores a heterogenous collection of children in named fields.\n\t * @remarks\n\t * Each field gets its own schema.\n\t /\n\tObject = 2,\n\t/\n\t A node which stores a single leaf value.\n\t /\n\tLeaf = 3,\n\t/\n\t A node which serves as a record, storing children under string keys.\n\t /\n\tRecord = 4,\n}\n\n/\n Metadata associated with a Node Schema.\n \n @remarks Specified via {@link NodeSchemaOptions.metadata}.\n \n @sealed\n * @public\n /\nexport interface NodeSchemaMetadata<out TCustomMetadata = unknown> {\n\t/\n\t User-defined metadata.\n\t /\n\treadonly custom?: TCustomMetadata \| undefined;\n\n\t/\n\t The description of the Node Schema.\n\t \n\t @remarks\n\t \n\t If provided, will be used by the system in scenarios where a description of the kind of node is useful.\n\t * E.g., when converting a Node Schema to {@link https://json-schema.org/ \| JSON Schema}, this description will be\n\t * used as the `description` property.\n\t /\n\treadonly description?: string \| undefined;\n}\n\n/\n Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.\n * @internal\n /\nexport function isTreeNodeSchemaClass<\n\tName extends string,\n\tKind extends NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue,\n\tTBuild,\n\tImplicitlyConstructable extends boolean,\n\tInfo,\n>(\n\tschema:\n\t\t\| TreeNodeSchema<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>\n\t\t\| TreeNodeSchemaClass<Name, Kind, TNode & TreeNode, TBuild, ImplicitlyConstructable, Info>,\n): schema is TreeNodeSchemaClass<\n\tName,\n\tKind,\n\tTNode & TreeNode,\n\tTBuild,\n\tImplicitlyConstructable,\n\tInfo\n> {\n\treturn schema.constructor !== undefined;\n}\n\n/\n Takes in `TreeNodeSchema[]` and returns a TypedNode union.\n * @privateRemarks\n * If a schema is both TreeNodeSchemaClass and TreeNodeSchemaNonClass, prefer TreeNodeSchemaClass since that includes subclasses properly.\n * @public\n /\nexport type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchemaClass<\n\tstring,\n\tNodeKind,\n\tinfer TNode\n>\n\t? TNode\n\t: T extends TreeNodeSchemaNonClass<string, NodeKind, infer TNode>\n\t\t? TNode\n\t\t: never;\n\n/\n Data which can be used as a node to be inserted.\n * Either an unhydrated node, or content to build a new node.\n \n @see {@link Input}\n \n @typeparam TSchemaInput - Schema to process.\n * @typeparam T - Do not specify: default value used as implementation detail.\n * @privateRemarks\n * This can't really be fully correct, since TreeNodeSchema's TNode is generally use covariantly but this code uses it contravariantly.\n * That makes this TreeNodeSchema actually invariant with respect to TNode, but doing that would break all `extends TreeNodeSchema` clauses.\n * As is, this works correctly in most realistic use-cases.\n \n One special case this makes is if the result of NodeFromSchema contains TreeNode, this must be an under constrained schema, so the result is set to never.\n * Note that applying UnionToIntersection on the result of NodeFromSchema<T> does not work since it breaks booleans.\n \n @public\n /\nexport type InsertableTypedNode<\n\tTSchema extends TreeNodeSchema,\n\tT = UnionToIntersection<TSchema>,\n> =\n\t\| (T extends TreeNodeSchema<string, NodeKind, TreeNode \| TreeLeafValue, never, true>\n\t\t\t? NodeBuilderData<T>\n\t\t\t: never)\n\t\| (T extends TreeNodeSchema\n\t\t\t? Unhydrated<TreeNode extends NodeFromSchema<T> ? never : NodeFromSchema<T>>\n\t\t\t: never);\n\n/\n Given a node's schema, return the corresponding object from which the node could be built.\n * @privateRemarks\n * This uses TreeNodeSchemaCore, and thus depends on TreeNodeSchemaCore.createFromInsertable for the typing.\n * This works almost the same as using TreeNodeSchema,\n * except that the more complex typing in TreeNodeSchema case breaks for non-class schema and leaks in `undefined` from optional crete parameters.\n * @system @public\n /\nexport type NodeBuilderData<T extends TreeNodeSchemaCore<string, NodeKind, boolean>> =\n\tT extends TreeNodeSchemaCore<string, NodeKind, boolean, unknown, infer TBuild>\n\t\t? TBuild\n\t\t: never;\n\n/\n Value that may be stored as a leaf node.\n * @remarks\n * Some limitations apply, see the documentation for {@link SchemaStatics.number} and {@link SchemaStatics.string} for those restrictions.\n * @public\n */\n// eslint-disable-next-line @rushstack/no-new-null\nexport type TreeLeafValue = number \| string \| boolean \| IFluidHandle \| null;\n"]}
1	+ {"version":3,"file":"treeNodeSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAqU7D;;GAEG;AACU,QAAA,iBAAiB,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AA6GvD;;;;;;;;;;;;;;;GAeG;AACH,IAAY,kBAaX;AAbD,WAAY,kBAAkB;IAC7B;;OAEG;IACH,2DAAQ,CAAA;IACR;;OAEG;IACH,yDAAO,CAAA;IACP;;OAEG;IACH,+DAAU,CAAA;AACX,CAAC,EAbW,kBAAkB,kCAAlB,kBAAkB,QAa7B;AAED;;GAEG;AACH,SAAgB,4BAA4B,CAC3C,MAAqD;IAErD,IAAA,iBAAM,EACL,yBAAiB,IAAI,MAAM,EAC3B,KAAK,CAAC,6FAA6F,CACnG,CAAC;IACF,MAAM,WAAW,GAAG,MAAmC,CAAC;IACxD,OAAO,WAAW,CAAC,yBAAiB,CAAC,CAAC;AACvC,CAAC;AATD,oEASC;AAED;;;;;GAKG;AACH,IAAY,QAuBX;AAvBD,WAAY,QAAQ;IACnB;;OAEG;IACH,qCAAO,CAAA;IACP;;OAEG;IACH,yCAAS,CAAA;IACT;;;;OAIG;IACH,2CAAU,CAAA;IACV;;OAEG;IACH,uCAAQ,CAAA;IACR;;OAEG;IACH,2CAAU,CAAA;AACX,CAAC,EAvBW,QAAQ,wBAAR,QAAQ,QAuBnB;AA4BD;;;GAGG;AACH,SAAgB,qBAAqB,CAQpC,MAE2F;IAS3F,OAAO,MAAM,CAAC,WAAW,KAAK,SAAS,CAAC;AACzC,CAAC;AApBD,sDAoBC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\n\nimport type { SimpleNodeSchemaBase } from \"./simpleNodeSchemaBase.js\";\nimport type { TreeNode } from \"./treeNode.js\";\nimport type { InternalTreeNode, Unhydrated } from \"./types.js\";\nimport type { UnionToIntersection } from \"../../util/index.js\";\nimport type { AllowedTypesFullEvaluated, AllowedTypesFull } from \"./allowedTypes.js\";\nimport type { Context } from \"./context.js\";\nimport type { FieldKey, NodeData } from \"../../core/index.js\";\nimport type { UnhydratedFlexTreeField } from \"./unhydratedFlexTree.js\";\nimport type { FactoryContent } from \"../unhydratedFlexTreeFromInsertable.js\";\n\n/\n Schema for a {@link TreeNode} or {@link TreeLeafValue}.\n \n @typeParam Name - The full (including scope) name/identifier for the schema.\n * @typeParam Kind - Which kind of node this schema is for.\n * @typeParam TNode - API for nodes that use this schema.\n * @typeParam TBuild - Data which can be used to construct an {@link Unhydrated} node of this type.\n * @typeParam Info - Data used when defining this schema.\n * @remarks\n * Captures the schema both as runtime data and compile time type information.\n * Use {@link SchemaFactory} to define schema.\n * Use `Tree.schema(value)` to lookup the schema for a {@link TreeNode} or {@link TreeLeafValue}.\n * @privateRemarks\n * TODO:\n * The long lists of type parameters here are awkward to deal with.\n * Switching to (or adding an option to use)\n * an interface based pattern with unordered named parameters for types like this would be a good idea.\n * The related `@system` types should be simple to port to the new pattern, but stable public one like this will need to support both:\n * the new one could either be added as a system type, or be recommended to replace this one (deprecating it).\n * @sealed @public\n /\nexport type TreeNodeSchema<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue = TreeNode \| TreeLeafValue,\n\tTBuild = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTCustomMetadata = unknown,\n> =\n\t\| (TNode extends TreeNode\n\t\t\t? TreeNodeSchemaClass<\n\t\t\t\t\tName,\n\t\t\t\t\tKind,\n\t\t\t\t\tTNode,\n\t\t\t\t\tTBuild,\n\t\t\t\t\tImplicitlyConstructable,\n\t\t\t\t\tInfo,\n\t\t\t\t\tnever,\n\t\t\t\t\tTCustomMetadata\n\t\t\t\t>\n\t\t\t: never)\n\t\| TreeNodeSchemaNonClass<\n\t\t\tName,\n\t\t\tKind,\n\t\t\tTNode,\n\t\t\tTBuild,\n\t\t\tImplicitlyConstructable,\n\t\t\tInfo,\n\t\t\tnever,\n\t\t\tTCustomMetadata\n\t >;\n\n/\n Schema which is not a class.\n * @remarks\n * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.\n * @privateRemarks\n * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.\n * @system @sealed @public\n /\nexport type TreeNodeSchemaNonClass<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue = TreeNode \| TreeLeafValue,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaCore<\n\tName,\n\tKind,\n\tImplicitlyConstructable,\n\tInfo,\n\tTInsertable,\n\tTCustomMetadata\n> &\n\t(undefined extends TConstructorExtra\n\t\t? {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Also allows InternalTreeNode.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\tcreate(data?: TInsertable \| TConstructorExtra): TNode;\n\t\t\t}\n\t\t: {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Also allows InternalTreeNode.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\tcreate(data: TInsertable \| TConstructorExtra): TNode;\n\t\t\t});\n\n/\n Tree node schema which is implemented using a class.\n * @remarks\n * Instances of this class are nodes in the tree.\n * This is also a constructor so that it can be subclassed.\n \n Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.\n * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer \"any\" in the d.ts file.\n \n When sub-classing a a `TreeNodeSchemaClass`, some extra rules must be followed:\n \n - Only ever use a single class from the schema's class hierarchy within a document and its schema.\n * For example, if using {@link SchemaFactory.object} you can do:\n * ```typescript\n * // Recommended \"customizable\" object schema pattern.\n * class Good extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \tpublic exampleCustomMethod(): void {\n * \t\tthis.exampleField++;\n * \t}\n * }\n * ```\n * But should avoid:\n * ```typescript\n * // This by itself is ok, and opts into \"POJO mode\".\n * const base = schemaFactory.object(\"A\", {});\n * // This is a bad pattern since it leaves two classes in scope which derive from the same SchemaFactory defined class.\n * // If both get used, its an error!\n * class Invalid extends base {}\n * ```\n \n - Do not modify the constructor input parameter types or values:\n * ```typescript\n * class Invalid extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \t// This Modifies the type of the constructor input.\n * \t// This is unsupported due to programmatic access to the constructor being used internally.\n * \tpublic constructor(a: number) {\n * \t\tsuper({ exampleField: a });\n * \t}\n * }\n * ```\n * @sealed @public\n /\nexport type TreeNodeSchemaClass<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode = TreeNode,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaCore<\n\tName,\n\tKind,\n\tImplicitlyConstructable,\n\tInfo,\n\tTInsertable,\n\tTCustomMetadata\n> &\n\t(undefined extends TConstructorExtra\n\t\t? {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @remarks\n\t\t\t\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t\t\t\t * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\t// The approach suggested by the linter here is more concise, but ir break intellisense for the constructor.\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t\t\t\tnew (data?: TInsertable \| InternalTreeNode \| TConstructorExtra): Unhydrated<TNode>;\n\t\t\t}\n\t\t: {\n\t\t\t\t/\n\t\t\t\t Constructs an {@link Unhydrated} node with this schema.\n\t\t\t\t * @remarks\n\t\t\t\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t\t\t\t * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.\n\t\t\t\t * @sealed\n\t\t\t\t /\n\t\t\t\t// The approach suggested by the linter here is more concise, but ir break intellisense for the constructor.\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t\t\t\tnew (data: TInsertable \| InternalTreeNode \| TConstructorExtra): Unhydrated<TNode>;\n\t\t\t});\n\n/\n Internal helper for utilities that return schema which can be used in class and non class formats depending on the API exposing it.\n /\nexport type TreeNodeSchemaBoth<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode extends TreeNode = TreeNode,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTConstructorExtra = never,\n\tTCustomMetadata = unknown,\n> = TreeNodeSchemaClass<\n\tName,\n\tKind,\n\tTNode,\n\tTInsertable,\n\tImplicitlyConstructable,\n\tInfo,\n\tTConstructorExtra,\n\tTCustomMetadata\n> &\n\tTreeNodeSchemaNonClass<\n\t\tName,\n\t\tKind,\n\t\tTNode,\n\t\tTInsertable,\n\t\tImplicitlyConstructable,\n\t\tInfo,\n\t\tTConstructorExtra,\n\t\tTCustomMetadata\n\t>;\n\n/\n Data common to all tree node schema.\n \n @remarks\n * Implementation detail of {@link TreeNodeSchema} which should be accessed instead of referring to this type directly.\n \n @privateRemarks\n * All implementations must implement {@link TreeNodeSchemaCorePrivate} as well.\n \n @sealed @public\n /\nexport interface TreeNodeSchemaCore<\n\tout Name extends string,\n\tout Kind extends NodeKind,\n\tout ImplicitlyConstructable extends boolean,\n\tout Info = unknown,\n\tout TInsertable = never,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBase<Kind, TCustomMetadata> {\n\t/\n\t Unique (within a document's schema) identifier used to associate nodes with their schema.\n\t * @remarks\n\t * This is used when encoding nodes, and when decoding nodes to re-associate them with the schema.\n\t * Since this decoding may happen in a different version of the application (or even a different application altogether),\n\t * this identifier should generally correspond to some specific semantics for the data (how to interpret the node with this identifier).\n\t * Any time the semantics change such that data would be misinterpreted if the old semantics were applied\n\t * (for example the units of a value are changed),\n\t * it is best practice to pick a new identifier.\n\t /\n\treadonly identifier: Name;\n\n\t/\n\t Data used to define this schema.\n\t \n\t @remarks\n\t * The format depends on the kind of node it is for.\n\t * For example, the \"object\" node kind could store the field schema here.\n\t /\n\treadonly info: Info;\n\n\t/\n\t When constructing insertable content,\n\t * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node\n\t * iff implicitlyConstructable is true.\n\t * @privateRemarks\n\t * Currently the logic for traversing insertable content,\n\t * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,\n\t * so if their constructors differ from what is supported, some cases will not work.\n\t * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.\n\t /\n\treadonly implicitlyConstructable: ImplicitlyConstructable;\n\n\t/\n\t All possible schema that a direct child of a node with this schema could have.\n\t \n\t Equivalently, this is also all schema directly referenced when defining this schema's allowed child types,\n\t * which is also the same as the set of schema referenced directly by the `Info` type parameter and the `info` property.\n\t * This property is simply re-exposing that information in an easier to traverse format consistent across all node kinds.\n\t * @remarks\n\t * Some kinds of nodes may have additional restrictions on children:\n\t * this set simply enumerates all directly referenced schema, and can be use to walk over all referenced schema types.\n\t \n\t This set cannot be used before the schema in it have been defined:\n\t * more specifically, when using lazy schema references (for example to make foreword references to schema which have not yet been defined),\n\t * users must wait until after the schema are defined to access this set.\n\t * @privateRemarks\n\t * Currently there isn't much use for this in the public API,\n\t * and it's possible this will want to be tweaked or renamed as part of a larger schema reflection API surface that might be added later.\n\t * To keep options option, this is marked `@system` for now.\n\t * @system\n\t /\n\treadonly childTypes: ReadonlySet<TreeNodeSchema>;\n\n\t/\n\t Constructs an instance of this node type.\n\t * @remarks\n\t * Due to TypeScript limitations, the return type of this method can not be very specific.\n\t * For {@link TreeNodeSchemaClass} prefer using the constructor directly for better typing.\n\t * For {@link TreeNodeSchemaNonClass} use `create`.\n\t \n\t @privateRemarks\n\t * This method signature provides a way to infer `TInsertable` without relying on the constructor, and to construct nodes from schema of unknown kind.\n\t * This makes customizations of the constructor not impact the typing of insertable content, allowing customization of the constructor,\n\t * as long as doing so only adds additional supported cases.\n\t \n\t This cannot be required to return `TNode`:\n\t * doing so breaks sub-classing of schema since they don't overload this method with a more specific return type.\n\t * @sealed @system\n\t /\n\tcreateFromInsertable(data: TInsertable): Unhydrated<TreeNode \| TreeLeafValue>;\n}\n\n/\n Symbol for use by {@link TreeNodeSchemaCorePrivate}.\n /\nexport const privateDataSymbol = Symbol(\"PrivateData\");\n\n/\n {@link TreeNodeSchemaCore} extended with some non-exported APIs.\n /\nexport interface TreeNodeSchemaCorePrivate<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTInsertable = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n\tTCustomMetadata = unknown,\n> extends TreeNodeSchemaCore<\n\t\tName,\n\t\tKind,\n\t\tImplicitlyConstructable,\n\t\tInfo,\n\t\tTInsertable,\n\t\tTCustomMetadata\n\t> {\n\t/\n\t Package private data provided by all {@link TreeNodeSchema}.\n\t * @remarks\n\t * Users can add custom statics to schema classes.\n\t * To reduce the risk of such statics colliding with properties used to implement the schema,\n\t * some of the private APIs are grouped together under this symbol.\n\t \n\t Note that there are still some properties which are not under a symbol and thus expose some risk of name collisions.\n\t * See {@link TreeNodeValid} for some such properties.\n\t /\n\treadonly [privateDataSymbol]: TreeNodeSchemaPrivateData;\n}\n\n/\n Package private data provided by all {@link TreeNodeSchema}.\n * @remarks\n * This data needs to be available before lazy schema references are resolved.\n * For data which is only available after lazy schema references are resolved,\n * see {@link TreeNodeSchemaInitializedData}, which can be accessed via {@link TreeNodeSchemaPrivateData.idempotentInitialize}.\n /\nexport interface TreeNodeSchemaPrivateData {\n\t/\n\t All possible annotated allowed types that a field under a node with this schema could have.\n\t * @remarks\n\t * In this case \"field\" includes anything that is a field in the internal (flex-tree) abstraction layer.\n\t * This includes the content field for arrays, and all the fields for map nodes.\n\t * If this node does not have fields (and thus is a leaf), the array will be empty.\n\t * @privateRemarks\n\t * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.\n\t * @system\n\t /\n\treadonly childAllowedTypes: readonly AllowedTypesFull[];\n\n\t/\n\t Idempotent initialization function that pre-caches data and can dereference lazy schema references.\n\t /\n\tidempotentInitialize(): TreeNodeSchemaInitializedData;\n}\n\n/\n Additional data about a given schema which is private to this package.\n * @remarks\n * Created by {@link TreeNodeValid.oneTimeSetup} and can involve dereferencing lazy schema references.\n /\nexport interface TreeNodeSchemaInitializedData {\n\t/\n\t All possible annotated allowed types that a field under a node with this schema could have.\n\t * @remarks\n\t * In this case \"field\" includes anything that is a field in the internal (flex-tree) abstraction layer.\n\t * This includes the content field for arrays, and all the fields for map nodes.\n\t * If this node does not have fields (and thus is a leaf), the array will be empty.\n\t \n\t This set cannot be used before the schema in it have been defined:\n\t * more specifically, when using lazy schema references (for example to make foreword references to schema which have not yet been defined),\n\t * users must wait until after the schema are defined to access this array.\n\t \n\t @privateRemarks\n\t * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.\n\t * @system\n\t /\n\treadonly childAllowedTypes: readonly AllowedTypesFullEvaluated[];\n\n\t/\n\t A {@link Context} which can be used for unhydrated nodes of this schema.\n\t /\n\treadonly context: Context;\n\n\t/\n\t Checks if data might be schema-compatible.\n\t \n\t @returns false if `data` is incompatible with `type` based on a cheap/shallow check.\n\t \n\t Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.\n\t /\n\tshallowCompatibilityTest(data: FactoryContent): CompatibilityLevel;\n\n\t/\n\t Convert data to a {@link FlexContent} representation.\n\t * @remarks\n\t * Data must be compatible with the schema according to {@link shallowCompatibilityTest}.\n\t \n\t TODO: use of `allowedTypes` is for fallbacks (for example NaN -\\> null).\n\t * This behavior should be moved to shallowCompatibilityTest instead.\n\t /\n\ttoFlexContent(data: FactoryContent, allowedTypes: ReadonlySet<TreeNodeSchema>): FlexContent;\n}\n\nexport type FlexContent = [NodeData, Map<FieldKey, UnhydratedFlexTreeField>];\n\n/\n Indicates a compatibility level for inferring a schema to apply to insertable data.\n * @remarks\n * Each schema allowed at a location in the tree has its compatibility level checked against the data being inserted.\n * The compatibility is considered unambiguous if there is a single schema with a higher compatibility than all others.\n \n This approach allows adding new compatible formats as a non breaking change.\n * If the new format was already compatible with some other schema, it can still be added as non-breaking as long as a lower compatibility level is used.\n * For example, support for constructing maps from record like objects was added in Fluid Framework 2.2.\n * This format (an object with fields) was already compatible with Object nodes at compatibility level Normal so the new format support for maps was added at compatibility level Low.\n * This ensures that existing code that was using object literals as insertable content where both objects and maps were allowed will continue to work,\n * assuming the objects are intended as ObjectNodes.\n * However new code can now be written using record like objects to construct maps, as long as the schema does not also allow Object nodes which are compatible with the data in that location.\n \n @see {@link ITreeConfigurationOptions.preventAmbiguity} for a related setting which interacts with this in a somewhat complex way.\n /\nexport enum CompatibilityLevel {\n\t/\n\t Not compatible. Constructor typing indicates incompatibility.\n\t /\n\tNone = 0,\n\t/\n\t Additional compatibility cases added in Fluid Framework 2.2.\n\t /\n\tLow = 1,\n\t/\n\t Compatible in Fluid Framework 2.0.\n\t /\n\tNormal = 2,\n}\n\n/\n Downcasts a {@link TreeNodeSchemaCore} to {@link TreeNodeSchemaCorePrivate} and get its {@link TreeNodeSchemaPrivateData}.\n /\nexport function getTreeNodeSchemaPrivateData(\n\tschema: TreeNodeSchemaCore<string, NodeKind, boolean>,\n): TreeNodeSchemaPrivateData {\n\tassert(\n\t\tprivateDataSymbol in schema,\n\t\t0xbc9 / All implementations of TreeNodeSchemaCore must also implement TreeNodeSchemaCorePrivate /,\n\t);\n\tconst schemaValid = schema as TreeNodeSchemaCorePrivate;\n\treturn schemaValid[privateDataSymbol];\n}\n\n/\n Kind of tree node.\n * @remarks\n * More kinds may be added over time, so do not assume this is an exhaustive set.\n * @public\n /\nexport enum NodeKind {\n\t/\n\t A node which serves as a map, storing children under string keys.\n\t /\n\tMap = 0,\n\t/\n\t A node which serves as an array, storing children in an ordered sequence.\n\t /\n\tArray = 1,\n\t/\n\t A node which stores a heterogenous collection of children in named fields.\n\t * @remarks\n\t * Each field gets its own schema.\n\t /\n\tObject = 2,\n\t/\n\t A node which stores a single leaf value.\n\t /\n\tLeaf = 3,\n\t/\n\t A node which serves as a record, storing children under string keys.\n\t /\n\tRecord = 4,\n}\n\n/\n Metadata associated with a Node Schema.\n \n @remarks Specified via {@link NodeSchemaOptions.metadata}.\n \n @sealed\n * @public\n /\nexport interface NodeSchemaMetadata<out TCustomMetadata = unknown> {\n\t/\n\t User-defined metadata.\n\t /\n\treadonly custom?: TCustomMetadata \| undefined;\n\n\t/\n\t The description of the Node Schema.\n\t \n\t @remarks\n\t \n\t If provided, will be used by the system in scenarios where a description of the kind of node is useful.\n\t * E.g., when converting a Node Schema to {@link https://json-schema.org/ \| JSON Schema}, this description will be\n\t * used as the `description` property.\n\t /\n\treadonly description?: string \| undefined;\n}\n\n/\n Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.\n * @internal\n /\nexport function isTreeNodeSchemaClass<\n\tName extends string,\n\tKind extends NodeKind,\n\tTNode extends TreeNode \| TreeLeafValue,\n\tTBuild,\n\tImplicitlyConstructable extends boolean,\n\tInfo,\n>(\n\tschema:\n\t\t\| TreeNodeSchema<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>\n\t\t\| TreeNodeSchemaClass<Name, Kind, TNode & TreeNode, TBuild, ImplicitlyConstructable, Info>,\n): schema is TreeNodeSchemaClass<\n\tName,\n\tKind,\n\tTNode & TreeNode,\n\tTBuild,\n\tImplicitlyConstructable,\n\tInfo\n> {\n\treturn schema.constructor !== undefined;\n}\n\n/\n Takes in `TreeNodeSchema[]` and returns a TypedNode union.\n * @privateRemarks\n * If a schema is both TreeNodeSchemaClass and TreeNodeSchemaNonClass, prefer TreeNodeSchemaClass since that includes subclasses properly.\n * @public\n /\nexport type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchemaClass<\n\tstring,\n\tNodeKind,\n\tinfer TNode\n>\n\t? TNode\n\t: T extends TreeNodeSchemaNonClass<string, NodeKind, infer TNode>\n\t\t? TNode\n\t\t: never;\n\n/\n Data which can be used as a node to be inserted.\n * Either an unhydrated node, or content to build a new node.\n \n @see {@link Input}\n \n @typeparam TSchemaInput - Schema to process.\n * @typeparam T - Do not specify: default value used as implementation detail.\n * @privateRemarks\n * This can't really be fully correct, since TreeNodeSchema's TNode is generally use covariantly but this code uses it contravariantly.\n * That makes this TreeNodeSchema actually invariant with respect to TNode, but doing that would break all `extends TreeNodeSchema` clauses.\n * As is, this works correctly in most realistic use-cases.\n \n One special case this makes is if the result of NodeFromSchema contains TreeNode, this must be an under constrained schema, so the result is set to never.\n * Note that applying UnionToIntersection on the result of NodeFromSchema<T> does not work since it breaks booleans.\n \n @public\n /\nexport type InsertableTypedNode<\n\tTSchema extends TreeNodeSchema,\n\tT = UnionToIntersection<TSchema>,\n> =\n\t\| (T extends TreeNodeSchema<string, NodeKind, TreeNode \| TreeLeafValue, never, true>\n\t\t\t? NodeBuilderData<T>\n\t\t\t: never)\n\t\| (T extends TreeNodeSchema\n\t\t\t? Unhydrated<TreeNode extends NodeFromSchema<T> ? never : NodeFromSchema<T>>\n\t\t\t: never);\n\n/\n Given a node's schema, return the corresponding object from which the node could be built.\n * @privateRemarks\n * This uses TreeNodeSchemaCore, and thus depends on TreeNodeSchemaCore.createFromInsertable for the typing.\n * This works almost the same as using TreeNodeSchema,\n * except that the more complex typing in TreeNodeSchema case breaks for non-class schema and leaks in `undefined` from optional crete parameters.\n * @system @public\n /\nexport type NodeBuilderData<T extends TreeNodeSchemaCore<string, NodeKind, boolean>> =\n\tT extends TreeNodeSchemaCore<string, NodeKind, boolean, unknown, infer TBuild>\n\t\t? TBuild\n\t\t: never;\n\n/\n Value that may be stored as a leaf node.\n * @remarks\n * Some limitations apply, see the documentation for {@link SchemaStatics.number} and {@link SchemaStatics.string} for those restrictions.\n * @public\n */\n// eslint-disable-next-line @rushstack/no-new-null\nexport type TreeLeafValue = number \| string \| boolean \| IFluidHandle \| null;\n"]}