@fluidframework/tree 2.51.0 → 2.52.0

package/dist/simple-tree/api/verboseTree.d.ts

@@ -5,7 +5,7 @@
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { type ITreeCursor, type ITreeCursorSynchronous } from "../../core/index.js";
 import type { ImplicitFieldSchema } from "../fieldSchema.js";
-import type { ImplicitAllowedTypes, TreeLeafValue } from "../core/index.js";
+import type { Context, TreeLeafValue } from "../core/index.js";
 import { type HandleConverter, type SchemalessParseOptions, type TreeEncodingOptions } from "./customTree.js";
 /**
  * Verbose encoding of a {@link TreeNode} or {@link TreeLeafValue}.
@@ -82,7 +82,7 @@ export declare function fieldCursorFromVerbose(data: VerboseTree[], options: Sch
 /**
  * Used to read a node cursor as a VerboseTree.
  */
-export declare function verboseFromCursor(reader: ITreeCursor, rootSchema: ImplicitAllowedTypes, options: TreeEncodingOptions): VerboseTree;
+export declare function verboseFromCursor(reader: ITreeCursor, context: Context, options: TreeEncodingOptions): VerboseTree;
 /**
  * Clones tree, replacing any handles.
  * @remarks

package/dist/simple-tree/api/verboseTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verboseTree.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/verboseTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAKpE,OAAO,EAKN,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,KAAK,EAAkB,oBAAoB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAe5F,OAAO,EAKN,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,GAAG,YAAY,IAC3C,eAAe,CAAC,OAAO,CAAC,GACxB,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,GACpC,OAAO,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,YAAY;IACtD;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;OAMG;IACH,MAAM,EACH,WAAW,CAAC,OAAO,CAAC,EAAE,GACtB;QACA,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;KACnC,CAAC;CACL;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,mBAAmB,GAC1B,sBAAsB,CAkDxB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,GAC7B,sBAAsB,CAExB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,WAAW,EAAE,EACnB,OAAO,EAAE,sBAAsB,GAC7B,sBAAsB,CAMxB;AAiFD;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,oBAAoB,EAChC,OAAO,EAAE,mBAAmB,GAC1B,WAAW,CASb;AAoBD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAC1C,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,WAAW,CAAC,CAAC,CAAC,CAEhB"}
+{"version":3,"file":"verboseTree.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/verboseTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAKpE,OAAO,EAMN,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAE3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAkB,MAAM,kBAAkB,CAAC;AAe/E,OAAO,EAKN,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,GAAG,YAAY,IAC3C,eAAe,CAAC,OAAO,CAAC,GACxB,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,GACpC,OAAO,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,YAAY;IACtD;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;OAMG;IACH,MAAM,EACH,WAAW,CAAC,OAAO,CAAC,EAAE,GACtB;QACA,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;KACnC,CAAC;CACL;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,mBAAmB,GAC1B,sBAAsB,CAkDxB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,GAC7B,sBAAsB,CAExB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,WAAW,EAAE,EACnB,OAAO,EAAE,sBAAsB,GAC7B,sBAAsB,CAMxB;AAiFD;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,GAC1B,WAAW,CAUb;AA2BD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAC1C,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,WAAW,CAAC,CAAC,CAAC,CAEhB"}

package/dist/simple-tree/api/verboseTree.js

@@ -10,10 +10,9 @@ const internal_2 = require("@fluidframework/core-utils/internal");
 const internal_3 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../../core/index.js");
 const index_js_2 = require("../../util/index.js");
-const index_js_3 = require("../core/index.js");
-const index_js_4 = require("../../feature-libraries/index.js");
+const index_js_3 = require("../../feature-libraries/index.js");
 const leafNodeSchema_js_1 = require("../leafNodeSchema.js");
-const index_js_5 = require("../node-kinds/index.js");
+const index_js_4 = require("../node-kinds/index.js");
 const customTree_js_1 = require("./customTree.js");
 const createContext_js_1 = require("../createContext.js");
 /**
@@ -32,7 +31,7 @@ function applySchemaToParserOptions(schema, options) {
                 encode: (type, key) => {
                     // translate stored key into property key.
                     const simpleNodeSchema = context.schema.get((0, index_js_2.brand)(type)) ?? (0, internal_2.fail)(0xb39 /* missing schema */);
-                    if ((0, index_js_5.isObjectNodeSchema)(simpleNodeSchema)) {
+                    if ((0, index_js_4.isObjectNodeSchema)(simpleNodeSchema)) {
                         const propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);
                         if (propertyKey !== undefined) {
                             return propertyKey;
@@ -50,7 +49,7 @@ function applySchemaToParserOptions(schema, options) {
                 },
                 parse: (type, inputKey) => {
                     const simpleNodeSchema = context.schema.get((0, index_js_2.brand)(type)) ?? (0, customTree_js_1.unknownTypeError)(type);
-                    if ((0, index_js_5.isObjectNodeSchema)(simpleNodeSchema)) {
+                    if ((0, index_js_4.isObjectNodeSchema)(simpleNodeSchema)) {
                         const info = simpleNodeSchema.flexKeyMap.get(inputKey);
                         if (info === undefined) {
                             throw new internal_3.UsageError(`Failed to parse VerboseTree due to unexpected key ${JSON.stringify(inputKey)} on type ${JSON.stringify(type)}.`);
@@ -69,7 +68,7 @@ exports.applySchemaToParserOptions = applySchemaToParserOptions;
  * @returns an {@link ITreeCursorSynchronous} for a single node in nodes mode.
  */
 function cursorFromVerbose(data, options) {
-    return (0, index_js_4.stackTreeNodeCursor)(verboseTreeAdapter(options), data);
+    return (0, index_js_3.stackTreeNodeCursor)(verboseTreeAdapter(options), data);
 }
 exports.cursorFromVerbose = cursorFromVerbose;
 /**
@@ -78,13 +77,13 @@ exports.cursorFromVerbose = cursorFromVerbose;
  * @returns an {@link ITreeCursorSynchronous} for a single field in fields mode.
  */
 function fieldCursorFromVerbose(data, options) {
-    return (0, index_js_4.stackTreeFieldCursor)(verboseTreeAdapter(options), { type: index_js_1.aboveRootPlaceholder, fields: data }, (0, index_js_1.keyAsDetachedField)(index_js_1.EmptyKey));
+    return (0, index_js_3.stackTreeFieldCursor)(verboseTreeAdapter(options), { type: index_js_1.aboveRootPlaceholder, fields: data }, (0, index_js_1.keyAsDetachedField)(index_js_1.EmptyKey));
 }
 exports.fieldCursorFromVerbose = fieldCursorFromVerbose;
 function verboseTreeAdapter(options) {
     return {
         value: (node) => {
-            return (0, index_js_4.isTreeValue)(node) ? node : undefined;
+            return (0, index_js_3.isTreeValue)(node) ? node : undefined;
         },
         type: (node) => {
             switch (typeof node) {
@@ -154,19 +153,20 @@ function verboseTreeAdapter(options) {
 /**
  * Used to read a node cursor as a VerboseTree.
  */
-function verboseFromCursor(reader, rootSchema, options) {
+function verboseFromCursor(reader, context, options) {
     const config = {
         useStoredKeys: false,
         ...options,
     };
-    const schemaMap = (0, createContext_js_1.getUnhydratedContext)(rootSchema).schema;
-    return verboseFromCursorInner(reader, config, schemaMap);
+    const storedSchemaMap = context.flexContext.schema.nodeSchema;
+    const schemaMap = context.schema;
+    return verboseFromCursorInner(reader, config, storedSchemaMap, schemaMap);
 }
 exports.verboseFromCursor = verboseFromCursor;
-function verboseFromCursorInner(reader, options, schema) {
-    const fields = (0, customTree_js_1.customFromCursor)(reader, options, schema, verboseFromCursorInner);
-    const nodeSchema = schema.get(reader.type) ?? (0, internal_2.fail)(0xb3c /* missing schema for type in cursor */);
-    if (nodeSchema.kind === index_js_3.NodeKind.Leaf) {
+function verboseFromCursorInner(reader, options, storedSchema, schema) {
+    const fields = (0, customTree_js_1.customFromCursor)(reader, options, storedSchema, schema, verboseFromCursorInner);
+    const nodeSchema = storedSchema.get(reader.type) ?? (0, internal_2.fail)(0xb3c /* missing schema for type in cursor */);
+    if (nodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
         return fields;
     }
     return {

package/dist/simple-tree/api/verboseTree.js.map

@@ -1 +1 @@
-{"version":3,"file":"verboseTree.js","sourceRoot":"","sources":["../../../src/simple-tree/api/verboseTree.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 type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\nimport { assert, fail } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport {\n\taboveRootPlaceholder,\n\tEmptyKey,\n\tkeyAsDetachedField,\n\ttype FieldKey,\n\ttype ITreeCursor,\n\ttype ITreeCursorSynchronous,\n} from \"../../core/index.js\";\nimport { brand } from \"../../util/index.js\";\nimport type { ImplicitFieldSchema } from \"../fieldSchema.js\";\nimport { NodeKind } from \"../core/index.js\";\nimport type { TreeNodeSchema, ImplicitAllowedTypes, TreeLeafValue } from \"../core/index.js\";\nimport {\n\tisTreeValue,\n\tstackTreeFieldCursor,\n\tstackTreeNodeCursor,\n\ttype CursorAdapter,\n} from \"../../feature-libraries/index.js\";\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"../leafNodeSchema.js\";\nimport { isObjectNodeSchema } from \"../node-kinds/index.js\";\nimport {\n\tcustomFromCursor,\n\treplaceHandles,\n\tunknownTypeError,\n\ttype CustomTreeNode,\n\ttype HandleConverter,\n\ttype SchemalessParseOptions,\n\ttype TreeEncodingOptions,\n} from \"./customTree.js\";\nimport { getUnhydratedContext } from \"../createContext.js\";\n\n/**\n * Verbose encoding of a {@link TreeNode} or {@link TreeLeafValue}.\n * @remarks\n * This is verbose meaning that every {@link TreeNode} is a {@link VerboseTreeNode}.\n * Any IFluidHandle values have been replaced by `THandle`.\n * @privateRemarks\n * This can store all possible simple trees,\n * but it can not store all possible trees representable by our internal representations like FlexTree and JsonableTree.\n * @alpha\n */\nexport type VerboseTree<THandle = IFluidHandle> =\n\t| VerboseTreeNode<THandle>\n\t| Exclude<TreeLeafValue, IFluidHandle>\n\t| THandle;\n\n/**\n * Verbose encoding of a {@link TreeNode}.\n * @remarks\n * This is verbose meaning that every {@link TreeNode} has an explicit `type` property, and `fields`.\n * This allowed VerboseTreeNode to be unambiguous regarding which type each node is without relying on symbols or hidden state.\n *\n * Any IFluidHandle values have been replaced by `THandle`. If the `THandle` is JSON compatible, then this type is JSON compatible as well.\n *\n * @privateRemarks\n * This type is only used for data which is copied into and out of the tree.\n * When being copied out, its fine to have the data be mutable since its a copy.\n *\n * When being copied in, we don't need to mutate, so we could use a readonly variant of this type.\n * however the copy in case (createFromVerbose) probably isn't harmed much by just reusing this type as is,\n * since if the caller has immutable data, TypeScript doesn't prevent assigning immutable data to a mutable type anyway.\n * Also relaxing the input methods to take readonly data would be a non-breaking change so it can be done later if desired.\n *\n * This format is simple-tree specialized alternative to {@link JsonableTree}.\n * This format allows for all simple-tree compatible trees to be represented.\n *\n * Unlike `JsonableTree`, leaf nodes are not boxed into node objects, and instead have their schema inferred from the value.\n * Additionally, sequence fields can only occur on a node that has a single sequence field (with the empty key)\n * replicating the behavior of simple-tree ArrayNodes.\n * @alpha\n */\nexport interface VerboseTreeNode<THandle = IFluidHandle> {\n\t/**\n\t * The meaning of this node.\n\t * Provides contexts/semantics for this node and its content.\n\t * @remarks\n\t * Typically used to associate a node with metadata (including a schema) and source code (types, behaviors, etc).\n\t * When used with this package's schema system, it will be the {@link TreeNodeSchemaCore.identifier}.\n\t */\n\ttype: string;\n\n\t/**\n\t * Content of this node.\n\t * For array nodes, an array of children.\n\t * For map and object nodes, an object which children under keys.\n\t * @remarks\n\t * For object nodes, the keys could be either the stored keys, or the property keys depending on usage.\n\t */\n\tfields:\n\t\t| VerboseTree<THandle>[]\n\t\t| {\n\t\t\t\t[key: string]: VerboseTree<THandle>;\n\t\t  };\n}\n\n/**\n * Use info from `schema` to convert `options` to {@link SchemalessParseOptions}.\n */\nexport function applySchemaToParserOptions(\n\tschema: ImplicitFieldSchema,\n\toptions: TreeEncodingOptions,\n): SchemalessParseOptions {\n\tconst config: Required<TreeEncodingOptions> = {\n\t\tuseStoredKeys: false,\n\t\t...options,\n\t};\n\n\tconst context = getUnhydratedContext(schema);\n\n\treturn {\n\t\tkeyConverter: config.useStoredKeys\n\t\t\t? undefined\n\t\t\t: {\n\t\t\t\t\tencode: (type, key: FieldKey): string => {\n\t\t\t\t\t\t// translate stored key into property key.\n\t\t\t\t\t\tconst simpleNodeSchema =\n\t\t\t\t\t\t\tcontext.schema.get(brand(type)) ?? fail(0xb39 /* missing schema */);\n\t\t\t\t\t\tif (isObjectNodeSchema(simpleNodeSchema)) {\n\t\t\t\t\t\t\tconst propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);\n\t\t\t\t\t\t\tif (propertyKey !== undefined) {\n\t\t\t\t\t\t\t\treturn propertyKey;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t// Looking up an out of schema key.\n\t\t\t\t\t\t\t// This must point to a non-existent field.\n\t\t\t\t\t\t\t// It's possible that the key, if we returned it unmodified, could point to some data\n\t\t\t\t\t\t\t// (for example if looking up a key which is a stored key already when using property keys).\n\t\t\t\t\t\t\t// Thus return an arbitrary key that was selected randomly, so should not exist on non-adversarial data:\n\t\t\t\t\t\t\tconst arbitrary = \"arbitrary unused key: fe71614a-bf3e-43b3-b7b0-4cef39538e90\";\n\t\t\t\t\t\t\tassert(\n\t\t\t\t\t\t\t\t!simpleNodeSchema.storedKeyToPropertyKey.has(brand(arbitrary)),\n\t\t\t\t\t\t\t\t0xa13 /* arbitrarily selected unused key was actually used */,\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\treturn arbitrary;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn key;\n\t\t\t\t\t},\n\t\t\t\t\tparse: (type, inputKey): FieldKey => {\n\t\t\t\t\t\tconst simpleNodeSchema = context.schema.get(brand(type)) ?? unknownTypeError(type);\n\t\t\t\t\t\tif (isObjectNodeSchema(simpleNodeSchema)) {\n\t\t\t\t\t\t\tconst info = simpleNodeSchema.flexKeyMap.get(inputKey);\n\t\t\t\t\t\t\tif (info === undefined) {\n\t\t\t\t\t\t\t\tthrow new UsageError(\n\t\t\t\t\t\t\t\t\t`Failed to parse VerboseTree due to unexpected key ${JSON.stringify(inputKey)} on type ${JSON.stringify(type)}.`,\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn info.storedKey;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn brand(inputKey);\n\t\t\t\t\t},\n\t\t\t\t},\n\t};\n}\n\n/**\n * Used to read a VerboseTree as a node cursor.\n *\n * @returns an {@link ITreeCursorSynchronous} for a single node in nodes mode.\n */\nexport function cursorFromVerbose(\n\tdata: VerboseTree,\n\toptions: SchemalessParseOptions,\n): ITreeCursorSynchronous {\n\treturn stackTreeNodeCursor(verboseTreeAdapter(options), data);\n}\n\n/**\n * Used to read a VerboseTree[] as a field cursor.\n *\n * @returns an {@link ITreeCursorSynchronous} for a single field in fields mode.\n */\nexport function fieldCursorFromVerbose(\n\tdata: VerboseTree[],\n\toptions: SchemalessParseOptions,\n): ITreeCursorSynchronous {\n\treturn stackTreeFieldCursor(\n\t\tverboseTreeAdapter(options),\n\t\t{ type: aboveRootPlaceholder, fields: data },\n\t\tkeyAsDetachedField(EmptyKey),\n\t);\n}\n\nfunction verboseTreeAdapter(options: SchemalessParseOptions): CursorAdapter<VerboseTree> {\n\treturn {\n\t\tvalue: (node: VerboseTree) => {\n\t\t\treturn isTreeValue(node) ? node : undefined;\n\t\t},\n\t\ttype: (node: VerboseTree) => {\n\t\t\tswitch (typeof node) {\n\t\t\t\tcase \"number\":\n\t\t\t\t\treturn brand(numberSchema.identifier);\n\t\t\t\tcase \"string\":\n\t\t\t\t\treturn brand(stringSchema.identifier);\n\t\t\t\tcase \"boolean\":\n\t\t\t\t\treturn brand(booleanSchema.identifier);\n\t\t\t\tdefault:\n\t\t\t\t\tif (node === null) {\n\t\t\t\t\t\treturn brand(nullSchema.identifier);\n\t\t\t\t\t}\n\t\t\t\t\tif (isFluidHandle(node)) {\n\t\t\t\t\t\treturn brand(handleSchema.identifier);\n\t\t\t\t\t}\n\t\t\t\t\treturn brand(node.type);\n\t\t\t}\n\t\t},\n\t\tkeysFromNode: (node: VerboseTree): readonly FieldKey[] => {\n\t\t\tswitch (typeof node) {\n\t\t\t\tcase \"object\": {\n\t\t\t\t\tif (node === null) {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t\tif (isFluidHandle(node)) {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t\tif (Array.isArray(node.fields)) {\n\t\t\t\t\t\treturn node.fields.length === 0 ? [] : [EmptyKey];\n\t\t\t\t\t}\n\n\t\t\t\t\tconst inputKeys = Object.keys(node.fields);\n\t\t\t\t\tconst converter = options.keyConverter;\n\t\t\t\t\tif (converter === undefined) {\n\t\t\t\t\t\treturn inputKeys as FieldKey[];\n\t\t\t\t\t}\n\t\t\t\t\treturn inputKeys.map((k) => converter.parse(node.type, k));\n\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\treturn [];\n\t\t\t}\n\t\t},\n\t\tgetFieldFromNode: (node: VerboseTree, key: FieldKey): readonly VerboseTree[] => {\n\t\t\t// Object.prototype.hasOwnProperty can return true for strings (ex: with key \"0\"), so we have to filter them out.\n\t\t\t// Rather than just special casing strings, we can handle them with an early return for all primitives.\n\t\t\tif (typeof node !== \"object\") {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (node === null) {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (isFluidHandle(node)) {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (Array.isArray(node.fields)) {\n\t\t\t\treturn key === EmptyKey ? node.fields : [];\n\t\t\t}\n\n\t\t\tconst convertedKey =\n\t\t\t\toptions.keyConverter === undefined ? key : options.keyConverter.encode(node.type, key);\n\n\t\t\tif (Object.prototype.hasOwnProperty.call(node.fields, convertedKey)) {\n\t\t\t\tconst field = node.fields[convertedKey];\n\t\t\t\treturn field === undefined ? [] : [field];\n\t\t\t}\n\n\t\t\treturn [];\n\t\t},\n\t};\n}\n\n/**\n * Used to read a node cursor as a VerboseTree.\n */\nexport function verboseFromCursor(\n\treader: ITreeCursor,\n\trootSchema: ImplicitAllowedTypes,\n\toptions: TreeEncodingOptions,\n): VerboseTree {\n\tconst config: Required<TreeEncodingOptions> = {\n\t\tuseStoredKeys: false,\n\t\t...options,\n\t};\n\n\tconst schemaMap = getUnhydratedContext(rootSchema).schema;\n\n\treturn verboseFromCursorInner(reader, config, schemaMap);\n}\n\nfunction verboseFromCursorInner(\n\treader: ITreeCursor,\n\toptions: Required<TreeEncodingOptions>,\n\tschema: ReadonlyMap<string, TreeNodeSchema>,\n): VerboseTree {\n\tconst fields = customFromCursor(reader, options, schema, verboseFromCursorInner);\n\tconst nodeSchema =\n\t\tschema.get(reader.type) ?? fail(0xb3c /* missing schema for type in cursor */);\n\tif (nodeSchema.kind === NodeKind.Leaf) {\n\t\treturn fields as TreeLeafValue;\n\t}\n\n\treturn {\n\t\ttype: reader.type,\n\t\tfields: fields as CustomTreeNode<VerboseTree>,\n\t};\n}\n\n/**\n * Clones tree, replacing any handles.\n * @remarks\n * A strongly types version of {@link replaceHandles}.\n * @alpha\n */\nexport function replaceVerboseTreeHandles<T>(\n\ttree: VerboseTree,\n\treplacer: HandleConverter<T>,\n): VerboseTree<T> {\n\treturn replaceHandles(tree, replacer) as VerboseTree<T>;\n}\n"]}
+{"version":3,"file":"verboseTree.js","sourceRoot":"","sources":["../../../src/simple-tree/api/verboseTree.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 type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\nimport { assert, fail } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport {\n\taboveRootPlaceholder,\n\tEmptyKey,\n\tkeyAsDetachedField,\n\tLeafNodeStoredSchema,\n\ttype FieldKey,\n\ttype ITreeCursor,\n\ttype ITreeCursorSynchronous,\n\ttype TreeNodeStoredSchema,\n} from \"../../core/index.js\";\nimport { brand } from \"../../util/index.js\";\nimport type { ImplicitFieldSchema } from \"../fieldSchema.js\";\nimport type { Context, TreeLeafValue, TreeNodeSchema } from \"../core/index.js\";\nimport {\n\tisTreeValue,\n\tstackTreeFieldCursor,\n\tstackTreeNodeCursor,\n\ttype CursorAdapter,\n} from \"../../feature-libraries/index.js\";\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"../leafNodeSchema.js\";\nimport { isObjectNodeSchema } from \"../node-kinds/index.js\";\nimport {\n\tcustomFromCursor,\n\treplaceHandles,\n\tunknownTypeError,\n\ttype CustomTreeNode,\n\ttype HandleConverter,\n\ttype SchemalessParseOptions,\n\ttype TreeEncodingOptions,\n} from \"./customTree.js\";\nimport { getUnhydratedContext } from \"../createContext.js\";\n\n/**\n * Verbose encoding of a {@link TreeNode} or {@link TreeLeafValue}.\n * @remarks\n * This is verbose meaning that every {@link TreeNode} is a {@link VerboseTreeNode}.\n * Any IFluidHandle values have been replaced by `THandle`.\n * @privateRemarks\n * This can store all possible simple trees,\n * but it can not store all possible trees representable by our internal representations like FlexTree and JsonableTree.\n * @alpha\n */\nexport type VerboseTree<THandle = IFluidHandle> =\n\t| VerboseTreeNode<THandle>\n\t| Exclude<TreeLeafValue, IFluidHandle>\n\t| THandle;\n\n/**\n * Verbose encoding of a {@link TreeNode}.\n * @remarks\n * This is verbose meaning that every {@link TreeNode} has an explicit `type` property, and `fields`.\n * This allowed VerboseTreeNode to be unambiguous regarding which type each node is without relying on symbols or hidden state.\n *\n * Any IFluidHandle values have been replaced by `THandle`. If the `THandle` is JSON compatible, then this type is JSON compatible as well.\n *\n * @privateRemarks\n * This type is only used for data which is copied into and out of the tree.\n * When being copied out, its fine to have the data be mutable since its a copy.\n *\n * When being copied in, we don't need to mutate, so we could use a readonly variant of this type.\n * however the copy in case (createFromVerbose) probably isn't harmed much by just reusing this type as is,\n * since if the caller has immutable data, TypeScript doesn't prevent assigning immutable data to a mutable type anyway.\n * Also relaxing the input methods to take readonly data would be a non-breaking change so it can be done later if desired.\n *\n * This format is simple-tree specialized alternative to {@link JsonableTree}.\n * This format allows for all simple-tree compatible trees to be represented.\n *\n * Unlike `JsonableTree`, leaf nodes are not boxed into node objects, and instead have their schema inferred from the value.\n * Additionally, sequence fields can only occur on a node that has a single sequence field (with the empty key)\n * replicating the behavior of simple-tree ArrayNodes.\n * @alpha\n */\nexport interface VerboseTreeNode<THandle = IFluidHandle> {\n\t/**\n\t * The meaning of this node.\n\t * Provides contexts/semantics for this node and its content.\n\t * @remarks\n\t * Typically used to associate a node with metadata (including a schema) and source code (types, behaviors, etc).\n\t * When used with this package's schema system, it will be the {@link TreeNodeSchemaCore.identifier}.\n\t */\n\ttype: string;\n\n\t/**\n\t * Content of this node.\n\t * For array nodes, an array of children.\n\t * For map and object nodes, an object which children under keys.\n\t * @remarks\n\t * For object nodes, the keys could be either the stored keys, or the property keys depending on usage.\n\t */\n\tfields:\n\t\t| VerboseTree<THandle>[]\n\t\t| {\n\t\t\t\t[key: string]: VerboseTree<THandle>;\n\t\t  };\n}\n\n/**\n * Use info from `schema` to convert `options` to {@link SchemalessParseOptions}.\n */\nexport function applySchemaToParserOptions(\n\tschema: ImplicitFieldSchema,\n\toptions: TreeEncodingOptions,\n): SchemalessParseOptions {\n\tconst config: Required<TreeEncodingOptions> = {\n\t\tuseStoredKeys: false,\n\t\t...options,\n\t};\n\n\tconst context = getUnhydratedContext(schema);\n\n\treturn {\n\t\tkeyConverter: config.useStoredKeys\n\t\t\t? undefined\n\t\t\t: {\n\t\t\t\t\tencode: (type, key: FieldKey): string => {\n\t\t\t\t\t\t// translate stored key into property key.\n\t\t\t\t\t\tconst simpleNodeSchema =\n\t\t\t\t\t\t\tcontext.schema.get(brand(type)) ?? fail(0xb39 /* missing schema */);\n\t\t\t\t\t\tif (isObjectNodeSchema(simpleNodeSchema)) {\n\t\t\t\t\t\t\tconst propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);\n\t\t\t\t\t\t\tif (propertyKey !== undefined) {\n\t\t\t\t\t\t\t\treturn propertyKey;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t// Looking up an out of schema key.\n\t\t\t\t\t\t\t// This must point to a non-existent field.\n\t\t\t\t\t\t\t// It's possible that the key, if we returned it unmodified, could point to some data\n\t\t\t\t\t\t\t// (for example if looking up a key which is a stored key already when using property keys).\n\t\t\t\t\t\t\t// Thus return an arbitrary key that was selected randomly, so should not exist on non-adversarial data:\n\t\t\t\t\t\t\tconst arbitrary = \"arbitrary unused key: fe71614a-bf3e-43b3-b7b0-4cef39538e90\";\n\t\t\t\t\t\t\tassert(\n\t\t\t\t\t\t\t\t!simpleNodeSchema.storedKeyToPropertyKey.has(brand(arbitrary)),\n\t\t\t\t\t\t\t\t0xa13 /* arbitrarily selected unused key was actually used */,\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\treturn arbitrary;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn key;\n\t\t\t\t\t},\n\t\t\t\t\tparse: (type, inputKey): FieldKey => {\n\t\t\t\t\t\tconst simpleNodeSchema = context.schema.get(brand(type)) ?? unknownTypeError(type);\n\t\t\t\t\t\tif (isObjectNodeSchema(simpleNodeSchema)) {\n\t\t\t\t\t\t\tconst info = simpleNodeSchema.flexKeyMap.get(inputKey);\n\t\t\t\t\t\t\tif (info === undefined) {\n\t\t\t\t\t\t\t\tthrow new UsageError(\n\t\t\t\t\t\t\t\t\t`Failed to parse VerboseTree due to unexpected key ${JSON.stringify(inputKey)} on type ${JSON.stringify(type)}.`,\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn info.storedKey;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn brand(inputKey);\n\t\t\t\t\t},\n\t\t\t\t},\n\t};\n}\n\n/**\n * Used to read a VerboseTree as a node cursor.\n *\n * @returns an {@link ITreeCursorSynchronous} for a single node in nodes mode.\n */\nexport function cursorFromVerbose(\n\tdata: VerboseTree,\n\toptions: SchemalessParseOptions,\n): ITreeCursorSynchronous {\n\treturn stackTreeNodeCursor(verboseTreeAdapter(options), data);\n}\n\n/**\n * Used to read a VerboseTree[] as a field cursor.\n *\n * @returns an {@link ITreeCursorSynchronous} for a single field in fields mode.\n */\nexport function fieldCursorFromVerbose(\n\tdata: VerboseTree[],\n\toptions: SchemalessParseOptions,\n): ITreeCursorSynchronous {\n\treturn stackTreeFieldCursor(\n\t\tverboseTreeAdapter(options),\n\t\t{ type: aboveRootPlaceholder, fields: data },\n\t\tkeyAsDetachedField(EmptyKey),\n\t);\n}\n\nfunction verboseTreeAdapter(options: SchemalessParseOptions): CursorAdapter<VerboseTree> {\n\treturn {\n\t\tvalue: (node: VerboseTree) => {\n\t\t\treturn isTreeValue(node) ? node : undefined;\n\t\t},\n\t\ttype: (node: VerboseTree) => {\n\t\t\tswitch (typeof node) {\n\t\t\t\tcase \"number\":\n\t\t\t\t\treturn brand(numberSchema.identifier);\n\t\t\t\tcase \"string\":\n\t\t\t\t\treturn brand(stringSchema.identifier);\n\t\t\t\tcase \"boolean\":\n\t\t\t\t\treturn brand(booleanSchema.identifier);\n\t\t\t\tdefault:\n\t\t\t\t\tif (node === null) {\n\t\t\t\t\t\treturn brand(nullSchema.identifier);\n\t\t\t\t\t}\n\t\t\t\t\tif (isFluidHandle(node)) {\n\t\t\t\t\t\treturn brand(handleSchema.identifier);\n\t\t\t\t\t}\n\t\t\t\t\treturn brand(node.type);\n\t\t\t}\n\t\t},\n\t\tkeysFromNode: (node: VerboseTree): readonly FieldKey[] => {\n\t\t\tswitch (typeof node) {\n\t\t\t\tcase \"object\": {\n\t\t\t\t\tif (node === null) {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t\tif (isFluidHandle(node)) {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t\tif (Array.isArray(node.fields)) {\n\t\t\t\t\t\treturn node.fields.length === 0 ? [] : [EmptyKey];\n\t\t\t\t\t}\n\n\t\t\t\t\tconst inputKeys = Object.keys(node.fields);\n\t\t\t\t\tconst converter = options.keyConverter;\n\t\t\t\t\tif (converter === undefined) {\n\t\t\t\t\t\treturn inputKeys as FieldKey[];\n\t\t\t\t\t}\n\t\t\t\t\treturn inputKeys.map((k) => converter.parse(node.type, k));\n\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\treturn [];\n\t\t\t}\n\t\t},\n\t\tgetFieldFromNode: (node: VerboseTree, key: FieldKey): readonly VerboseTree[] => {\n\t\t\t// Object.prototype.hasOwnProperty can return true for strings (ex: with key \"0\"), so we have to filter them out.\n\t\t\t// Rather than just special casing strings, we can handle them with an early return for all primitives.\n\t\t\tif (typeof node !== \"object\") {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (node === null) {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (isFluidHandle(node)) {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tif (Array.isArray(node.fields)) {\n\t\t\t\treturn key === EmptyKey ? node.fields : [];\n\t\t\t}\n\n\t\t\tconst convertedKey =\n\t\t\t\toptions.keyConverter === undefined ? key : options.keyConverter.encode(node.type, key);\n\n\t\t\tif (Object.prototype.hasOwnProperty.call(node.fields, convertedKey)) {\n\t\t\t\tconst field = node.fields[convertedKey];\n\t\t\t\treturn field === undefined ? [] : [field];\n\t\t\t}\n\n\t\t\treturn [];\n\t\t},\n\t};\n}\n\n/**\n * Used to read a node cursor as a VerboseTree.\n */\nexport function verboseFromCursor(\n\treader: ITreeCursor,\n\tcontext: Context,\n\toptions: TreeEncodingOptions,\n): VerboseTree {\n\tconst config: Required<TreeEncodingOptions> = {\n\t\tuseStoredKeys: false,\n\t\t...options,\n\t};\n\n\tconst storedSchemaMap = context.flexContext.schema.nodeSchema;\n\tconst schemaMap = context.schema;\n\n\treturn verboseFromCursorInner(reader, config, storedSchemaMap, schemaMap);\n}\n\nfunction verboseFromCursorInner(\n\treader: ITreeCursor,\n\toptions: Required<TreeEncodingOptions>,\n\tstoredSchema: ReadonlyMap<string, TreeNodeStoredSchema>,\n\tschema: ReadonlyMap<string, TreeNodeSchema>,\n): VerboseTree {\n\tconst fields = customFromCursor(\n\t\treader,\n\t\toptions,\n\t\tstoredSchema,\n\t\tschema,\n\t\tverboseFromCursorInner,\n\t);\n\tconst nodeSchema =\n\t\tstoredSchema.get(reader.type) ?? fail(0xb3c /* missing schema for type in cursor */);\n\tif (nodeSchema instanceof LeafNodeStoredSchema) {\n\t\treturn fields as TreeLeafValue;\n\t}\n\n\treturn {\n\t\ttype: reader.type,\n\t\tfields: fields as CustomTreeNode<VerboseTree>,\n\t};\n}\n\n/**\n * Clones tree, replacing any handles.\n * @remarks\n * A strongly types version of {@link replaceHandles}.\n * @alpha\n */\nexport function replaceVerboseTreeHandles<T>(\n\ttree: VerboseTree,\n\treplacer: HandleConverter<T>,\n): VerboseTree<T> {\n\treturn replaceHandles(tree, replacer) as VerboseTree<T>;\n}\n"]}

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

@@ -169,7 +169,7 @@ export type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> = Unannotate
  * Removes annotations from an allowed type.
  * @system @alpha
  */
-export type UnannotateAllowedType<T extends AnnotatedAllowedType> = T extends AnnotatedAllowedType<infer X> ? [X] : T;
+export type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? [X] : T;
 /**
  * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any
  * lazy schema declarations.
@@ -179,11 +179,17 @@ export type UnannotateAllowedType<T extends AnnotatedAllowedType> = T extends An
  *
  * @internal
  */
-export declare function normalizeAllowedTypes(types: ImplicitAllowedTypes): ReadonlySet<TreeNodeSchema>;
+export declare function normalizeAllowedTypes(types: ImplicitAnnotatedAllowedTypes): ReadonlySet<TreeNodeSchema>;
 /**
- * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
+ * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist
+ * and eagerly evaluating any lazy schema declarations.
+ *
+ * @remarks
+ * Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ * type is frozen and should not be modified after being passed in.
  */
-export declare function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(type: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>): AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>;
+export declare function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(type: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>): AnnotatedAllowedType<T>;
 /**
  * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, by eagerly evaluating any
  * lazy schema declarations and adding empty metadata if it doesn't already exist.
@@ -199,6 +205,12 @@ export declare function normalizeAnnotatedAllowedTypes(types: ImplicitAnnotatedA
  * This does not evaluate any lazy schemas.
  */
 export declare function unannotateImplicitAllowedTypes<Types extends ImplicitAnnotatedAllowedTypes>(types: Types): UnannotateImplicitAllowedTypes<Types>;
+/**
+ * Converts an {@link AnnotatedAllowedType} to an {@link LazyItem} by removing any annotations.
+ * @remarks
+ * This does not evaluate any lazy schemas.
+ */
+export declare function unannotateAllowedType<Type extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>>(allowedType: Type): UnannotateAllowedType<Type>;
 /**
  * Returns the schema referenced by the {@link LazyItem}.
  * @remarks
@@ -206,6 +218,10 @@ export declare function unannotateImplicitAllowedTypes<Types extends ImplicitAnn
  * @alpha
  */
 export declare function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>): T;
+/**
+ * Throws a UsageError if the provided schema is undefined, most likely due to being used before it was initialized.
+ */
+export declare function checkForUninitializedSchema(schema: ImplicitAnnotatedAllowedTypes | LazyItem<TreeNodeSchema>): void;
 /**
  * Indicates that the provided schema is the "most derived" version in its class hierarchy.
  *

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

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

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

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.markSchemaMostDerived = exports.evaluateLazySchema = exports.unannotateImplicitAllowedTypes = exports.normalizeAnnotatedAllowedTypes = exports.normalizeToAnnotatedAllowedType = exports.normalizeAllowedTypes = exports.isAnnotatedAllowedType = exports.isAnnotatedAllowedTypes = void 0;
+exports.markSchemaMostDerived = exports.checkForUninitializedSchema = exports.evaluateLazySchema = exports.unannotateAllowedType = exports.unannotateImplicitAllowedTypes = exports.normalizeAnnotatedAllowedTypes = exports.normalizeToAnnotatedAllowedType = exports.normalizeAllowedTypes = exports.isAnnotatedAllowedType = exports.isAnnotatedAllowedTypes = void 0;
 const internal_1 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../../util/index.js");
 const flexList_js_1 = require("./flexList.js");
@@ -14,6 +14,7 @@ const treeNodeValid_js_1 = require("./treeNodeValid.js");
  * Checks if the input is an {@link AnnotatedAllowedTypes}.
  */
 function isAnnotatedAllowedTypes(allowedTypes) {
+    checkForUninitializedSchema(allowedTypes);
     return (
     // Class based schema, and lazy schema references report type "function": filtering them out with typeof makes narrowing based on members mostly safe
     typeof allowedTypes === "object" && "metadata" in allowedTypes && "types" in allowedTypes);
@@ -23,7 +24,9 @@ exports.isAnnotatedAllowedTypes = isAnnotatedAllowedTypes;
  * Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.
  */
 function isAnnotatedAllowedType(allowedType) {
-    return "metadata" in allowedType && "type" in allowedType;
+    checkForUninitializedSchema(allowedType);
+    // Class based schema, and lazy schema references report type "function": filtering them out with typeof makes narrowing based on members mostly safe
+    return typeof allowedType === "object" && "metadata" in allowedType && "type" in allowedType;
 }
 exports.isAnnotatedAllowedType = isAnnotatedAllowedType;
 /**
@@ -36,26 +39,37 @@ exports.isAnnotatedAllowedType = isAnnotatedAllowedType;
  * @internal
  */
 function normalizeAllowedTypes(types) {
+    // remove annotations before normalizing
+    const unannotated = unannotateImplicitAllowedTypes(types);
     const normalized = new Set();
-    if ((0, index_js_1.isReadonlyArray)(types)) {
+    if ((0, index_js_1.isReadonlyArray)(unannotated)) {
         // Types array must not be modified after it is normalized since that would result in the user of the normalized data having wrong (out of date) content.
-        Object.freeze(types);
-        for (const lazyType of types) {
+        Object.freeze(unannotated);
+        for (const lazyType of unannotated) {
             normalized.add(evaluateLazySchema(lazyType));
         }
     }
     else {
-        normalized.add(evaluateLazySchema(types));
+        normalized.add(evaluateLazySchema(unannotated));
     }
     return normalized;
 }
 exports.normalizeAllowedTypes = normalizeAllowedTypes;
 /**
- * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
+ * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist
+ * and eagerly evaluating any lazy schema declarations.
+ *
+ * @remarks
+ * Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ * type is frozen and should not be modified after being passed in.
  */
 function normalizeToAnnotatedAllowedType(type) {
     return isAnnotatedAllowedType(type)
-        ? type
+        ? {
+            metadata: type.metadata,
+            type: evaluateLazySchema(type.type),
+        }
         : {
             metadata: {},
             type,
@@ -110,14 +124,25 @@ exports.normalizeAnnotatedAllowedTypes = normalizeAnnotatedAllowedTypes;
  */
 function unannotateImplicitAllowedTypes(types) {
     return (isAnnotatedAllowedTypes(types)
-        ? types.types.map((allowedType) => isAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType)
+        ? types.types.map(unannotateAllowedType)
         : (0, index_js_1.isReadonlyArray)(types)
-            ? types.map((allowedType) => isAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType)
+            ? types.map(unannotateAllowedType)
             : isAnnotatedAllowedType(types)
                 ? types.type
                 : types);
 }
 exports.unannotateImplicitAllowedTypes = unannotateImplicitAllowedTypes;
+/**
+ * Converts an {@link AnnotatedAllowedType} to an {@link LazyItem} by removing any annotations.
+ * @remarks
+ * This does not evaluate any lazy schemas.
+ */
+function unannotateAllowedType(allowedType) {
+    return isAnnotatedAllowedType(allowedType)
+        ? allowedType.type
+        : allowedType;
+}
+exports.unannotateAllowedType = unannotateAllowedType;
 const cachedLazyItem = new WeakMap();
 /**
  * Returns the schema referenced by the {@link LazyItem}.
@@ -129,13 +154,20 @@ function evaluateLazySchema(value) {
     const evaluatedSchema = (0, flexList_js_1.isLazy)(value)
         ? (0, index_js_1.getOrCreate)(cachedLazyItem, value, value)
         : value;
-    if (evaluatedSchema === undefined) {
-        throw new internal_1.UsageError(`Encountered an undefined schema. This could indicate that some referenced schema has not yet been instantiated.`);
-    }
+    checkForUninitializedSchema(evaluatedSchema);
     markSchemaMostDerived(evaluatedSchema);
     return evaluatedSchema;
 }
 exports.evaluateLazySchema = evaluateLazySchema;
+/**
+ * Throws a UsageError if the provided schema is undefined, most likely due to being used before it was initialized.
+ */
+function checkForUninitializedSchema(schema) {
+    if (schema === undefined) {
+        throw new internal_1.UsageError(`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.`);
+    }
+}
+exports.checkForUninitializedSchema = checkForUninitializedSchema;
 /**
  * Indicates that the provided schema is the "most derived" version in its class hierarchy.
  *

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

@@ -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\";\n\nimport { getOrCreate, isReadonlyArray, type IsUnion } 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\";\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 * @privateRemarks\n * Code reading data from this should use `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 * @alpha\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 * Stores annotations for a set of evaluated annotated allowed types.\n * @alpha\n */\nexport interface NormalizedAnnotatedAllowedTypes {\n\t/**\n\t * Annotations that apply to a set of allowed types.\n\t */\n\treadonly metadata: AllowedTypesMetadata;\n\t/**\n\t * All the evaluated allowed types that the annotations apply to. The types themselves are also individually annotated.\n\t */\n\treadonly types: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n}\n\n/**\n * Checks if the input is an {@link AnnotatedAllowedTypes}.\n */\nexport function isAnnotatedAllowedTypes(\n\tallowedTypes: ImplicitAnnotatedAllowedTypes,\n): allowedTypes is AnnotatedAllowedTypes {\n\treturn (\n\t\t// Class based schema, and lazy schema references report type \"function\": filtering them out with typeof makes narrowing based on members mostly safe\n\t\ttypeof allowedTypes === \"object\" && \"metadata\" in allowedTypes && \"types\" in allowedTypes\n\t);\n}\n\n/**\n * Stores annotations for a set of allowed types.\n * @alpha\n */\nexport interface AnnotatedAllowedTypes {\n\t/**\n\t * Annotations that apply to a set of allowed types.\n\t */\n\treadonly metadata: AllowedTypesMetadata;\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: readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];\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 * @alpha\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\treturn \"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 * @alpha\n */\nexport interface AllowedTypeMetadata {\n\t/**\n\t * User defined metadata\n\t */\n\treadonly custom?: unknown;\n\n\t// TODO metadata for enablable types will be added here\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 * @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 * @privateRemarks\n * Code reading data from this should use `normalizeAllowedTypes` to ensure consistent handling, caching, nice errors etc.\n * @public\n */\nexport type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;\n\n/**\n * Types of {@link TreeNode|TreeNodes} or {@link TreeLeafValue|TreeLeafValues} allowed at a location in a tree with\n * additional metadata associated with the location they're allowed at.\n * @alpha\n */\nexport type ImplicitAnnotatedAllowedTypes =\n\t| TreeNodeSchema\n\t| AnnotatedAllowedType\n\t| AnnotatedAllowedTypes\n\t| readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];\n\n/**\n * Returns an {@link ImplicitAllowedTypes} that is equivalent to the input without annotations.\n * @system @alpha\n */\nexport type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> =\n\tT extends AnnotatedAllowedTypes\n\t\t? UnannotateAllowedTypes<T>\n\t\t: T extends AnnotatedAllowedType\n\t\t\t? UnannotateAllowedType<T>\n\t\t\t: T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]\n\t\t\t\t? UnannotateAllowedTypesList<T>\n\t\t\t\t: T extends TreeNodeSchema\n\t\t\t\t\t? T\n\t\t\t\t\t: never;\n\n/**\n * Removes annotations from a list of allowed types that may contain annotations.\n * @system @alpha\n */\nexport type UnannotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: UnannotateAllowedTypeOrLazyItem<T[I]>;\n};\n\n/**\n * Removes annotations from an allowed type that may contain annotations.\n * @system @alpha\n */\nexport type UnannotateAllowedTypeOrLazyItem<\n\tT extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>,\n> = T extends AnnotatedAllowedType<infer X> ? X : T;\n\n/**\n * Removes all annotations from a set of allowed types.\n * @system @alpha\n */\nexport type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> =\n\tUnannotateAllowedTypesList<T[\"types\"]>;\n\n/**\n * Removes annotations from an allowed type.\n * @system @alpha\n */\nexport type UnannotateAllowedType<T extends AnnotatedAllowedType> =\n\tT extends AnnotatedAllowedType<infer X> ? [X] : T;\n\n/**\n * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any\n * lazy schema declarations.\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 *\n * @internal\n */\nexport function normalizeAllowedTypes(\n\ttypes: ImplicitAllowedTypes,\n): ReadonlySet<TreeNodeSchema> {\n\tconst normalized = new Set<TreeNodeSchema>();\n\tif (isReadonlyArray(types)) {\n\t\t// Types array must not be modified after it is normalized since that would result in the user of the normalized data having wrong (out of date) content.\n\t\tObject.freeze(types);\n\t\tfor (const lazyType of types) {\n\t\t\tnormalized.add(evaluateLazySchema(lazyType));\n\t\t}\n\t} else {\n\t\tnormalized.add(evaluateLazySchema(types));\n\t}\n\treturn normalized;\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 TreeNodeSchema>(\n\ttype: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>,\n): AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<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 * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, 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 normalizeAnnotatedAllowedTypes(\n\ttypes: ImplicitAnnotatedAllowedTypes,\n): NormalizedAnnotatedAllowedTypes {\n\tconst typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;\n\tconst annotatedTypes: AnnotatedAllowedType<TreeNodeSchema>[] = [];\n\tif (isReadonlyArray(typesWithoutAnnotation)) {\n\t\tfor (const annotatedType of typesWithoutAnnotation) {\n\t\t\tif (isAnnotatedAllowedType(annotatedType)) {\n\t\t\t\tannotatedTypes.push({\n\t\t\t\t\ttype: evaluateLazySchema(annotatedType.type),\n\t\t\t\t\tmetadata: annotatedType.metadata,\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tannotatedTypes.push({ type: evaluateLazySchema(annotatedType), metadata: {} });\n\t\t\t}\n\t\t}\n\t} else {\n\t\tif (isAnnotatedAllowedType(typesWithoutAnnotation)) {\n\t\t\tannotatedTypes.push({\n\t\t\t\ttype: evaluateLazySchema(typesWithoutAnnotation.type),\n\t\t\t\tmetadata: typesWithoutAnnotation.metadata,\n\t\t\t});\n\t\t} else {\n\t\t\tannotatedTypes.push({ type: evaluateLazySchema(typesWithoutAnnotation), metadata: {} });\n\t\t}\n\t}\n\n\treturn {\n\t\tmetadata: isAnnotatedAllowedTypes(types) ? types.metadata : {},\n\t\ttypes: annotatedTypes,\n\t};\n}\n\n/**\n * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing\n * any annotations.\n * @remarks\n * This does not evaluate any lazy schemas.\n */\nexport function unannotateImplicitAllowedTypes<Types extends ImplicitAnnotatedAllowedTypes>(\n\ttypes: Types,\n): UnannotateImplicitAllowedTypes<Types> {\n\treturn (\n\t\tisAnnotatedAllowedTypes(types)\n\t\t\t? types.types.map((allowedType) =>\n\t\t\t\t\tisAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType,\n\t\t\t\t)\n\t\t\t: isReadonlyArray(types)\n\t\t\t\t? types.map((allowedType) =>\n\t\t\t\t\t\tisAnnotatedAllowedType(allowedType) ? allowedType.type : allowedType,\n\t\t\t\t\t)\n\t\t\t\t: isAnnotatedAllowedType(types)\n\t\t\t\t\t? (types.type as UnannotateImplicitAllowedTypes<Types>)\n\t\t\t\t\t: types\n\t) as UnannotateImplicitAllowedTypes<Types>;\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\tif (evaluatedSchema === 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.`,\n\t\t);\n\t}\n\tmarkSchemaMostDerived(evaluatedSchema);\n\treturn evaluatedSchema;\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 [contravariant](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)) over the schema.\n * (See also, [TypeScript Variance Annotations](https://www.typescriptlang.org/docs/handbook/2/generics.html#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 manually unrolled 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 LazyItem<\n\t\t\t\t\tinfer 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}[number];\n"]}
+{"version":3,"file":"allowedTypes.js","sourceRoot":"","sources":["../../../src/simple-tree/core/allowedTypes.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uEAAsE;AAEtE,kDAAiF;AACjF,+CAA4E;AAC5E,2DAK6B;AAC7B,yDAA2D;AAyD3D;;GAEG;AACH,SAAgB,uBAAuB,CACtC,YAA2C;IAE3C,2BAA2B,CAAC,YAAY,CAAC,CAAC;IAC1C,OAAO;IACN,qJAAqJ;IACrJ,OAAO,YAAY,KAAK,QAAQ,IAAI,UAAU,IAAI,YAAY,IAAI,OAAO,IAAI,YAAY,CACzF,CAAC;AACH,CAAC;AARD,0DAQC;AA8BD;;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;AA8GD;;;;;;;;GAQG;AACH,SAAgB,qBAAqB,CACpC,KAAoC;IAEpC,wCAAwC;IACxC,MAAM,WAAW,GAAG,8BAA8B,CAAC,KAAK,CAAC,CAAC;IAC1D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC7C,IAAI,IAAA,0BAAe,EAAC,WAAW,CAAC,EAAE,CAAC;QAClC,yJAAyJ;QACzJ,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3B,KAAK,MAAM,QAAQ,IAAI,WAAW,EAAE,CAAC;YACpC,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC9C,CAAC;IACF,CAAC;SAAM,CAAC;QACP,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,UAAU,CAAC;AACnB,CAAC;AAhBD,sDAgBC;AAED;;;;;;;;GAQG;AACH,SAAgB,+BAA+B,CAC9C,IAAqE;IAErE,OAAO,sBAAsB,CAAC,IAAI,CAAC;QAClC,CAAC,CAAC;YACA,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;SACnC;QACF,CAAC,CAAC;YACA,QAAQ,EAAE,EAAE;YACZ,IAAI;SACJ,CAAC;AACL,CAAC;AAZD,0EAYC;AAED;;;;;;GAMG;AACH,SAAgB,8BAA8B,CAC7C,KAAoC;IAEpC,MAAM,sBAAsB,GAAG,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IACpF,MAAM,cAAc,GAA2C,EAAE,CAAC;IAClE,IAAI,IAAA,0BAAe,EAAC,sBAAsB,CAAC,EAAE,CAAC;QAC7C,KAAK,MAAM,aAAa,IAAI,sBAAsB,EAAE,CAAC;YACpD,IAAI,sBAAsB,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC3C,cAAc,CAAC,IAAI,CAAC;oBACnB,IAAI,EAAE,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC;oBAC5C,QAAQ,EAAE,aAAa,CAAC,QAAQ;iBAChC,CAAC,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACP,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;YAChF,CAAC;QACF,CAAC;IACF,CAAC;SAAM,CAAC;QACP,IAAI,sBAAsB,CAAC,sBAAsB,CAAC,EAAE,CAAC;YACpD,cAAc,CAAC,IAAI,CAAC;gBACnB,IAAI,EAAE,kBAAkB,CAAC,sBAAsB,CAAC,IAAI,CAAC;gBACrD,QAAQ,EAAE,sBAAsB,CAAC,QAAQ;aACzC,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACP,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,CAAC,sBAAsB,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QACzF,CAAC;IACF,CAAC;IAED,OAAO;QACN,QAAQ,EAAE,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;QAC9D,KAAK,EAAE,cAAc;KACrB,CAAC;AACH,CAAC;AA/BD,wEA+BC;AAED;;;;;GAKG;AACH,SAAgB,8BAA8B,CAC7C,KAAY;IAEZ,OAAO,CACN,uBAAuB,CAAC,KAAK,CAAC;QAC7B,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,qBAAqB,CAAC;QACxC,CAAC,CAAC,IAAA,0BAAe,EAAC,KAAK,CAAC;YACvB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,qBAAqB,CAAC;YAClC,CAAC,CAAC,sBAAsB,CAAC,KAAK,CAAC;gBAC9B,CAAC,CAAC,KAAK,CAAC,IAAI;gBACZ,CAAC,CAAC,KAAK,CAC+B,CAAC;AAC5C,CAAC;AAZD,wEAYC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CAEnC,WAAiB;IAClB,OAAO,sBAAsB,CAAC,WAAW,CAAC;QACzC,CAAC,CAAE,WAAW,CAAC,IAAoC;QACnD,CAAC,CAAE,WAA2C,CAAC;AACjD,CAAC;AAND,sDAMC;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,MAAgE;IAEhE,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\";\n\nimport { getOrCreate, isReadonlyArray, type IsUnion } 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\";\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 * @privateRemarks\n * Code reading data from this should use `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 * @alpha\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 * Stores annotations for a set of evaluated annotated allowed types.\n * @alpha\n */\nexport interface NormalizedAnnotatedAllowedTypes {\n\t/**\n\t * Annotations that apply to a set of allowed types.\n\t */\n\treadonly metadata: AllowedTypesMetadata;\n\t/**\n\t * All the evaluated allowed types that the annotations apply to. The types themselves are also individually annotated.\n\t */\n\treadonly types: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n}\n\n/**\n * Checks if the input is an {@link AnnotatedAllowedTypes}.\n */\nexport function isAnnotatedAllowedTypes(\n\tallowedTypes: ImplicitAnnotatedAllowedTypes,\n): allowedTypes is AnnotatedAllowedTypes {\n\tcheckForUninitializedSchema(allowedTypes);\n\treturn (\n\t\t// Class based schema, and lazy schema references report type \"function\": filtering them out with typeof makes narrowing based on members mostly safe\n\t\ttypeof allowedTypes === \"object\" && \"metadata\" in allowedTypes && \"types\" in allowedTypes\n\t);\n}\n\n/**\n * Stores annotations for a set of allowed types.\n * @alpha\n */\nexport interface AnnotatedAllowedTypes {\n\t/**\n\t * Annotations that apply to a set of allowed types.\n\t */\n\treadonly metadata: AllowedTypesMetadata;\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: readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];\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 * @alpha\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 * @alpha\n */\nexport interface AllowedTypeMetadata {\n\t/**\n\t * User defined metadata\n\t */\n\treadonly custom?: unknown;\n\n\t// TODO metadata for enablable types will be added here\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 * @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 * @privateRemarks\n * Code reading data from this should use `normalizeAllowedTypes` to ensure consistent handling, caching, nice errors etc.\n * @public\n */\nexport type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;\n\n/**\n * Types of {@link TreeNode|TreeNodes} or {@link TreeLeafValue|TreeLeafValues} allowed at a location in a tree with\n * additional metadata associated with the location they're allowed at.\n * @alpha\n */\nexport type ImplicitAnnotatedAllowedTypes =\n\t| TreeNodeSchema\n\t| AnnotatedAllowedType\n\t| AnnotatedAllowedTypes\n\t| readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];\n\n/**\n * Returns an {@link ImplicitAllowedTypes} that is equivalent to the input without annotations.\n * @system @alpha\n */\nexport type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> =\n\tT extends AnnotatedAllowedTypes\n\t\t? UnannotateAllowedTypes<T>\n\t\t: T extends AnnotatedAllowedType\n\t\t\t? UnannotateAllowedType<T>\n\t\t\t: T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]\n\t\t\t\t? UnannotateAllowedTypesList<T>\n\t\t\t\t: T extends TreeNodeSchema\n\t\t\t\t\t? T\n\t\t\t\t\t: never;\n\n/**\n * Removes annotations from a list of allowed types that may contain annotations.\n * @system @alpha\n */\nexport type UnannotateAllowedTypesList<\n\tT extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[],\n> = {\n\t[I in keyof T]: UnannotateAllowedTypeOrLazyItem<T[I]>;\n};\n\n/**\n * Removes annotations from an allowed type that may contain annotations.\n * @system @alpha\n */\nexport type UnannotateAllowedTypeOrLazyItem<\n\tT extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>,\n> = T extends AnnotatedAllowedType<infer X> ? X : T;\n\n/**\n * Removes all annotations from a set of allowed types.\n * @system @alpha\n */\nexport type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> =\n\tUnannotateAllowedTypesList<T[\"types\"]>;\n\n/**\n * Removes annotations from an allowed type.\n * @system @alpha\n */\nexport type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> =\n\tT extends AnnotatedAllowedType<infer X> ? [X] : T;\n\n/**\n * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any\n * lazy schema declarations.\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 *\n * @internal\n */\nexport function normalizeAllowedTypes(\n\ttypes: ImplicitAnnotatedAllowedTypes,\n): ReadonlySet<TreeNodeSchema> {\n\t// remove annotations before normalizing\n\tconst unannotated = unannotateImplicitAllowedTypes(types);\n\tconst normalized = new Set<TreeNodeSchema>();\n\tif (isReadonlyArray(unannotated)) {\n\t\t// Types array must not be modified after it is normalized since that would result in the user of the normalized data having wrong (out of date) content.\n\t\tObject.freeze(unannotated);\n\t\tfor (const lazyType of unannotated) {\n\t\t\tnormalized.add(evaluateLazySchema(lazyType));\n\t\t}\n\t} else {\n\t\tnormalized.add(evaluateLazySchema(unannotated));\n\t}\n\treturn normalized;\n}\n\n/**\n * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist\n * and eagerly evaluating any lazy schema declarations.\n *\n * @remarks\n * Note: this must only be called after all required schemas have been declared, otherwise evaluation of\n * recursive schemas may fail.\n * type is frozen and should not be modified after being passed in.\n */\nexport function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(\n\ttype: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>,\n): AnnotatedAllowedType<T> {\n\treturn isAnnotatedAllowedType(type)\n\t\t? {\n\t\t\t\tmetadata: type.metadata,\n\t\t\t\ttype: evaluateLazySchema(type.type),\n\t\t\t}\n\t\t: {\n\t\t\t\tmetadata: {},\n\t\t\t\ttype,\n\t\t\t};\n}\n\n/**\n * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, 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 normalizeAnnotatedAllowedTypes(\n\ttypes: ImplicitAnnotatedAllowedTypes,\n): NormalizedAnnotatedAllowedTypes {\n\tconst typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;\n\tconst annotatedTypes: AnnotatedAllowedType<TreeNodeSchema>[] = [];\n\tif (isReadonlyArray(typesWithoutAnnotation)) {\n\t\tfor (const annotatedType of typesWithoutAnnotation) {\n\t\t\tif (isAnnotatedAllowedType(annotatedType)) {\n\t\t\t\tannotatedTypes.push({\n\t\t\t\t\ttype: evaluateLazySchema(annotatedType.type),\n\t\t\t\t\tmetadata: annotatedType.metadata,\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tannotatedTypes.push({ type: evaluateLazySchema(annotatedType), metadata: {} });\n\t\t\t}\n\t\t}\n\t} else {\n\t\tif (isAnnotatedAllowedType(typesWithoutAnnotation)) {\n\t\t\tannotatedTypes.push({\n\t\t\t\ttype: evaluateLazySchema(typesWithoutAnnotation.type),\n\t\t\t\tmetadata: typesWithoutAnnotation.metadata,\n\t\t\t});\n\t\t} else {\n\t\t\tannotatedTypes.push({ type: evaluateLazySchema(typesWithoutAnnotation), metadata: {} });\n\t\t}\n\t}\n\n\treturn {\n\t\tmetadata: isAnnotatedAllowedTypes(types) ? types.metadata : {},\n\t\ttypes: annotatedTypes,\n\t};\n}\n\n/**\n * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing\n * any annotations.\n * @remarks\n * This does not evaluate any lazy schemas.\n */\nexport function unannotateImplicitAllowedTypes<Types extends ImplicitAnnotatedAllowedTypes>(\n\ttypes: Types,\n): UnannotateImplicitAllowedTypes<Types> {\n\treturn (\n\t\tisAnnotatedAllowedTypes(types)\n\t\t\t? types.types.map(unannotateAllowedType)\n\t\t\t: isReadonlyArray(types)\n\t\t\t\t? types.map(unannotateAllowedType)\n\t\t\t\t: isAnnotatedAllowedType(types)\n\t\t\t\t\t? types.type\n\t\t\t\t\t: types\n\t) as UnannotateImplicitAllowedTypes<Types>;\n}\n\n/**\n * Converts an {@link AnnotatedAllowedType} to an {@link LazyItem} by removing any annotations.\n * @remarks\n * This does not evaluate any lazy schemas.\n */\nexport function unannotateAllowedType<\n\tType extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>,\n>(allowedType: Type): UnannotateAllowedType<Type> {\n\treturn isAnnotatedAllowedType(allowedType)\n\t\t? (allowedType.type as UnannotateAllowedType<Type>)\n\t\t: (allowedType as UnannotateAllowedType<Type>);\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: ImplicitAnnotatedAllowedTypes | LazyItem<TreeNodeSchema>,\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 [contravariant](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)) over the schema.\n * (See also, [TypeScript Variance Annotations](https://www.typescriptlang.org/docs/handbook/2/generics.html#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 manually unrolled 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 LazyItem<\n\t\t\t\t\tinfer 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}[number];\n"]}

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

@@ -31,12 +31,23 @@ export declare class Context {
      * This design mirrors how {@link FlexTreeSchema} are accessed off the {@link FlexTreeContext}, making the migration away from them simpler.
      */
     readonly schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>;
+    static schemaMapFromRootSchema(rootSchema: NormalizedAnnotatedAllowedTypes): ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>;
     /**
      * Builds the context.
      * @remarks
      * Since this walks the schema, it must not be invoked during schema declaration or schema forward references could fail to be resolved.
      */
-    constructor(rootSchema: NormalizedAnnotatedAllowedTypes, flexContext: FlexTreeContext);
+    constructor(flexContext: FlexTreeContext, 
+    /**
+     * All schema which could transitively be used under the associated node.
+     * @remarks
+     * While generally {@link TreeNodeSchema} are referenced as objects and thus do not need to be looked up by identifier,
+     * there are a few cases (mainly constructing new TreeNodes from existing tree data) where such a lookup is useful.
+     * Having this map in the context addresses this use-case.
+     * @privateRemarks
+     * This design mirrors how {@link FlexTreeSchema} are accessed off the {@link FlexTreeContext}, making the migration away from them simpler.
+     */
+    schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>);
 }
 /**
  * Extends {@link Context} with additional information from the view and/or tree which becomes known when a {@link TreeNode} is hydrated,
@@ -44,6 +55,6 @@ export declare class Context {
  */
 export declare class HydratedContext extends Context {
     readonly flexContext: FlexTreeHydratedContext;
-    constructor(rootSchema: NormalizedAnnotatedAllowedTypes, flexContext: FlexTreeHydratedContext);
+    constructor(flexContext: FlexTreeHydratedContext, schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>);
 }
 //# sourceMappingURL=context.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EACX,eAAe,EACf,uBAAuB,EACvB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;;;;;;;;;;;GAYG;AACH,qBAAa,OAAO;aAmBF,WAAW,EAAE,eAAe;IAlB7C;;;;;;;;OAQG;IACH,SAAgB,MAAM,EAAE,WAAW,CAAC,wBAAwB,EAAE,cAAc,CAAC,CAAC;IAE9E;;;;OAIG;gBAEF,UAAU,EAAE,+BAA+B,EAC3B,WAAW,EAAE,eAAe;CAU7C;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,OAAO;aAGjB,WAAW,EAAE,uBAAuB;gBAD7D,UAAU,EAAE,+BAA+B,EAClB,WAAW,EAAE,uBAAuB;CAI9D"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EACX,eAAe,EACf,uBAAuB,EACvB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;;;;;;;;;;;GAYG;AACH,qBAAa,OAAO;aAmBF,WAAW,EAAE,eAAe;IAC5C;;;;;;;;OAQG;aACa,MAAM,EAAE,WAAW,CAAC,wBAAwB,EAAE,cAAc,CAAC;WA5BhE,uBAAuB,CACpC,UAAU,EAAE,+BAA+B,GACzC,WAAW,CAAC,wBAAwB,EAAE,cAAc,CAAC;IAUxD;;;;OAIG;gBAEc,WAAW,EAAE,eAAe;IAC5C;;;;;;;;OAQG;IACa,MAAM,EAAE,WAAW,CAAC,wBAAwB,EAAE,cAAc,CAAC;CAE9E;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,OAAO;aAEjB,WAAW,EAAE,uBAAuB;gBAApC,WAAW,EAAE,uBAAuB,EAC7D,MAAM,EAAE,WAAW,CAAC,wBAAwB,EAAE,cAAc,CAAC;CAI9D"}

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

@@ -21,19 +21,32 @@ const walkSchema_js_1 = require("./walkSchema.js");
  * This design is the same as {@link FlexTreeContext} with its base type and {@link FlexTreeHydratedContext} extending it.
  */
 class Context {
-    /**
-     * Builds the context.
-     * @remarks
-     * Since this walks the schema, it must not be invoked during schema declaration or schema forward references could fail to be resolved.
-     */
-    constructor(rootSchema, flexContext) {
-        this.flexContext = flexContext;
+    static schemaMapFromRootSchema(rootSchema) {
         const schema = new Map();
         (0, walkSchema_js_1.walkAllowedTypes)(rootSchema, {
             node(nodeSchema) {
                 schema.set((0, index_js_1.brand)(nodeSchema.identifier), nodeSchema);
             },
         });
+        return schema;
+    }
+    /**
+     * Builds the context.
+     * @remarks
+     * Since this walks the schema, it must not be invoked during schema declaration or schema forward references could fail to be resolved.
+     */
+    constructor(flexContext, 
+    /**
+     * All schema which could transitively be used under the associated node.
+     * @remarks
+     * While generally {@link TreeNodeSchema} are referenced as objects and thus do not need to be looked up by identifier,
+     * there are a few cases (mainly constructing new TreeNodes from existing tree data) where such a lookup is useful.
+     * Having this map in the context addresses this use-case.
+     * @privateRemarks
+     * This design mirrors how {@link FlexTreeSchema} are accessed off the {@link FlexTreeContext}, making the migration away from them simpler.
+     */
+    schema) {
+        this.flexContext = flexContext;
         this.schema = schema;
     }
 }
@@ -43,8 +56,8 @@ exports.Context = Context;
  * associating it with the containing {@link TreeView}.
  */
 class HydratedContext extends Context {
-    constructor(rootSchema, flexContext) {
-        super(rootSchema, flexContext);
+    constructor(flexContext, schema) {
+        super(flexContext, schema);
         this.flexContext = flexContext;
     }
 }