@fluidframework/tree 2.118.0 → 3.0.0

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

@@ -4,7 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkAllowedTypes = exports.walkNodeSchema = void 0;
+exports.walkNodeSchema = walkNodeSchema;
+exports.walkAllowedTypes = walkAllowedTypes;
 const allowedTypes_js_1 = require("./allowedTypes.js");
 const treeNodeSchema_js_1 = require("./treeNodeSchema.js");
 /**
@@ -33,7 +34,6 @@ function walkNodeSchema(schema, visitor, visitedSet) {
     // This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.
     visitor.node?.(schema);
 }
-exports.walkNodeSchema = walkNodeSchema;
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `allowedTypes`, applying the visitor pattern.
  * @internal
@@ -46,5 +46,4 @@ function walkAllowedTypes(annotatedAllowedTypes, visitor, visitedSet = new Set()
     }
     visitor.allowedTypes?.(annotatedAllowedTypes);
 }
-exports.walkAllowedTypes = walkAllowedTypes;
 //# sourceMappingURL=walkSchema.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"walkSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/core/walkSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uDAK2B;AAC3B,2DAAwF;AAExF;;;GAGG;AACH,SAAgB,cAAc,CAC7B,MAAsB,EACtB,OAAsB,EACtB,UAA+B;IAE/B,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IAED,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEvB,0DAA0D;IAC1D,iMAAiM;IACjM,wBAAwB;IACxB,IAAA,uCAAqB,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAErC,wGAAwG;IACxG,kFAAkF;IAClF,0DAA0D;IAC1D,MAAM,qBAAqB,GAAG,IAAA,gDAA4B,EAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;IAErF,KAAK,MAAM,iBAAiB,IAAI,qBAAqB,EAAE,CAAC;QACvD,gBAAgB,CACf,IAAA,2DAAyC,EAAC,iBAAiB,CAAC,EAC5D,OAAO,EACP,UAAU,CACV,CAAC;IACH,CAAC;IAED,kFAAkF;IAClF,4CAA4C;IAC5C,wGAAwG;IACxG,gIAAgI;IAChI,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;AACxB,CAAC;AAlCD,wCAkCC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAC/B,qBAAgD,EAChD,OAAsB,EACtB,aAAkC,IAAI,GAAG,EAAE;IAE3C,KAAK,MAAM,WAAW,IAAI,qBAAqB,CAAC,KAAK,EAAE,CAAC;QACvD,IAAI,CAAC,OAAO,CAAC,iBAAiB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9D,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QACvD,CAAC;IACF,CAAC;IACD,OAAO,CAAC,YAAY,EAAE,CAAC,qBAAqB,CAAC,CAAC;AAC/C,CAAC;AAXD,4CAWC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tnormalizeAndEvaluateAnnotatedAllowedTypes,\n\ttype AnnotatedAllowedType,\n\ttype AllowedTypesFullEvaluated,\n\tmarkSchemaMostDerived,\n} from \"./allowedTypes.js\";\nimport { getTreeNodeSchemaPrivateData, type TreeNodeSchema } from \"./treeNodeSchema.js\";\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.\n * @internal\n */\nexport function walkNodeSchema(\n\tschema: TreeNodeSchema,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema>,\n): void {\n\tif (visitedSet.has(schema)) {\n\t\treturn;\n\t}\n\n\tvisitedSet.add(schema);\n\n\t// Ensure all reachable schema are marked as most derived.\n\t// This ensures if multiple schema extending the same schema factory generated class are present (or have had instances of them constructed, or get instances of them constructed in the future),\n\t// an error is reported.\n\tmarkSchemaMostDerived(schema, false);\n\n\t// Since walkNodeSchema is used in the implementation of TreeNodeSchemaPrivateData.idempotentInitialize,\n\t// Avoid depending on it here to avoid circular dependencies for recursive schema.\n\t// Instead normalize/evaluate the allowed types as needed.\n\tconst annotatedAllowedTypes = getTreeNodeSchemaPrivateData(schema).childAllowedTypes;\n\n\tfor (const fieldAllowedTypes of annotatedAllowedTypes) {\n\t\twalkAllowedTypes(\n\t\t\tnormalizeAndEvaluateAnnotatedAllowedTypes(fieldAllowedTypes),\n\t\t\tvisitor,\n\t\t\tvisitedSet,\n\t\t);\n\t}\n\n\t// This visit is done at the end so the traversal order is most inner types first.\n\t// This was picked since when fixing errors,\n\t// working from the inner types out to the types that use them will probably go better than the reverse.\n\t// This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.\n\tvisitor.node?.(schema);\n}\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `allowedTypes`, applying the visitor pattern.\n * @internal\n */\nexport function walkAllowedTypes(\n\tannotatedAllowedTypes: AllowedTypesFullEvaluated,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema> = new Set(),\n): void {\n\tfor (const allowedType of annotatedAllowedTypes.types) {\n\t\tif ((visitor.allowedTypeFilter ?? (() => true))(allowedType)) {\n\t\t\twalkNodeSchema(allowedType.type, visitor, visitedSet);\n\t\t}\n\t}\n\tvisitor.allowedTypes?.(annotatedAllowedTypes);\n}\n\n/**\n * Callbacks and options for use in {@link walkFieldSchema} / {@link walkAllowedTypes} / {@link walkNodeSchema}.\n * @internal\n */\nexport interface SchemaVisitor {\n\t/**\n\t * Called once for each node schema reached.\n\t */\n\tnode?: (schema: TreeNodeSchema) => void;\n\t/**\n\t * Called once for each set of allowed types.\n\t * @remarks\n\t * This includes every field, as well as the allowed types for maps and arrays nodes and the root if starting at {@link walkAllowedTypes}.\n\t *\n\t * Each allowed types in the schema is visited as it was in the original schema except for normalization.\n\t *\n\t * After this is called {@link SchemaVisitor.allowedTypeFilter} is applied to each allowed type in the schema to determine which of them are walked into.\n\t */\n\tallowedTypes?: (allowedTypes: AllowedTypesFullEvaluated) => void;\n\t/**\n\t * If true, will walk into this `allowedType`.\n\t * If false, the `allowedType` will not be walked into.\n\t *\n\t * If not provided, all allowedTypes will be walked into.\n\t * @remarks\n\t * Called after {@link SchemaVisitor.allowedTypes}.\n\t * @privateRemarks\n\t * It would be possible to combine this with `allowedTypes` into a single callback, but for the current usage this separation is more convenient.\n\t */\n\tallowedTypeFilter?: (allowedType: AnnotatedAllowedType<TreeNodeSchema>) => boolean;\n}\n"]}
+{"version":3,"file":"walkSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/core/walkSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAcH,wCAkCC;AAMD,4CAWC;AA/DD,uDAK2B;AAC3B,2DAAwF;AAExF;;;GAGG;AACH,SAAgB,cAAc,CAC7B,MAAsB,EACtB,OAAsB,EACtB,UAA+B;IAE/B,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IAED,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEvB,0DAA0D;IAC1D,iMAAiM;IACjM,wBAAwB;IACxB,IAAA,uCAAqB,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAErC,wGAAwG;IACxG,kFAAkF;IAClF,0DAA0D;IAC1D,MAAM,qBAAqB,GAAG,IAAA,gDAA4B,EAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;IAErF,KAAK,MAAM,iBAAiB,IAAI,qBAAqB,EAAE,CAAC;QACvD,gBAAgB,CACf,IAAA,2DAAyC,EAAC,iBAAiB,CAAC,EAC5D,OAAO,EACP,UAAU,CACV,CAAC;IACH,CAAC;IAED,kFAAkF;IAClF,4CAA4C;IAC5C,wGAAwG;IACxG,gIAAgI;IAChI,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;AACxB,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAC/B,qBAAgD,EAChD,OAAsB,EACtB,aAAkC,IAAI,GAAG,EAAE;IAE3C,KAAK,MAAM,WAAW,IAAI,qBAAqB,CAAC,KAAK,EAAE,CAAC;QACvD,IAAI,CAAC,OAAO,CAAC,iBAAiB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9D,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QACvD,CAAC;IACF,CAAC;IACD,OAAO,CAAC,YAAY,EAAE,CAAC,qBAAqB,CAAC,CAAC;AAC/C,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tnormalizeAndEvaluateAnnotatedAllowedTypes,\n\ttype AnnotatedAllowedType,\n\ttype AllowedTypesFullEvaluated,\n\tmarkSchemaMostDerived,\n} from \"./allowedTypes.js\";\nimport { getTreeNodeSchemaPrivateData, type TreeNodeSchema } from \"./treeNodeSchema.js\";\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.\n * @internal\n */\nexport function walkNodeSchema(\n\tschema: TreeNodeSchema,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema>,\n): void {\n\tif (visitedSet.has(schema)) {\n\t\treturn;\n\t}\n\n\tvisitedSet.add(schema);\n\n\t// Ensure all reachable schema are marked as most derived.\n\t// This ensures if multiple schema extending the same schema factory generated class are present (or have had instances of them constructed, or get instances of them constructed in the future),\n\t// an error is reported.\n\tmarkSchemaMostDerived(schema, false);\n\n\t// Since walkNodeSchema is used in the implementation of TreeNodeSchemaPrivateData.idempotentInitialize,\n\t// Avoid depending on it here to avoid circular dependencies for recursive schema.\n\t// Instead normalize/evaluate the allowed types as needed.\n\tconst annotatedAllowedTypes = getTreeNodeSchemaPrivateData(schema).childAllowedTypes;\n\n\tfor (const fieldAllowedTypes of annotatedAllowedTypes) {\n\t\twalkAllowedTypes(\n\t\t\tnormalizeAndEvaluateAnnotatedAllowedTypes(fieldAllowedTypes),\n\t\t\tvisitor,\n\t\t\tvisitedSet,\n\t\t);\n\t}\n\n\t// This visit is done at the end so the traversal order is most inner types first.\n\t// This was picked since when fixing errors,\n\t// working from the inner types out to the types that use them will probably go better than the reverse.\n\t// This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.\n\tvisitor.node?.(schema);\n}\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `allowedTypes`, applying the visitor pattern.\n * @internal\n */\nexport function walkAllowedTypes(\n\tannotatedAllowedTypes: AllowedTypesFullEvaluated,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema> = new Set(),\n): void {\n\tfor (const allowedType of annotatedAllowedTypes.types) {\n\t\tif ((visitor.allowedTypeFilter ?? (() => true))(allowedType)) {\n\t\t\twalkNodeSchema(allowedType.type, visitor, visitedSet);\n\t\t}\n\t}\n\tvisitor.allowedTypes?.(annotatedAllowedTypes);\n}\n\n/**\n * Callbacks and options for use in {@link walkFieldSchema} / {@link walkAllowedTypes} / {@link walkNodeSchema}.\n * @internal\n */\nexport interface SchemaVisitor {\n\t/**\n\t * Called once for each node schema reached.\n\t */\n\tnode?: (schema: TreeNodeSchema) => void;\n\t/**\n\t * Called once for each set of allowed types.\n\t * @remarks\n\t * This includes every field, as well as the allowed types for maps and arrays nodes and the root if starting at {@link walkAllowedTypes}.\n\t *\n\t * Each allowed types in the schema is visited as it was in the original schema except for normalization.\n\t *\n\t * After this is called {@link SchemaVisitor.allowedTypeFilter} is applied to each allowed type in the schema to determine which of them are walked into.\n\t */\n\tallowedTypes?: (allowedTypes: AllowedTypesFullEvaluated) => void;\n\t/**\n\t * If true, will walk into this `allowedType`.\n\t * If false, the `allowedType` will not be walked into.\n\t *\n\t * If not provided, all allowedTypes will be walked into.\n\t * @remarks\n\t * Called after {@link SchemaVisitor.allowedTypes}.\n\t * @privateRemarks\n\t * It would be possible to combine this with `allowedTypes` into a single callback, but for the current usage this separation is more convenient.\n\t */\n\tallowedTypeFilter?: (allowedType: AnnotatedAllowedType<TreeNodeSchema>) => boolean;\n}\n"]}

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

@@ -6,22 +6,21 @@ import type { TreeNode } from "./treeNode.js";
 import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
 /**
  * An internal brand to improve compiler performance.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  * @privateRemarks
  * The identifier of a {@link TreeNode}'s schema.
  * This allows the type checker to distinguish different node types more efficiently than via {@link typeSchemaSymbol}.
- * @deprecated External code should use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.
  * @system @public
  */
-export declare const typeNameSymbol: unique symbol;
+export declare const schemaIdentifierBrand: unique symbol;
 /**
  * The type of a {@link TreeNode}.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
  * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  *
  * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.
  * Instead construct a real node of the desired type using its constructor.
@@ -98,7 +97,7 @@ export interface WithType<out TName extends string = string, out TKind extends N
     /**
      * Type symbol, marking a type in a way to increase type safety via strong type checking.
      *
-     * Use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use `WithType` instead of the symbols directly.
+     * Use {@link TreeNodeApi.schema | Tree.schema(theNode)} for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.
      * @remarks
      * This should be redundant with {@link typeSchemaSymbol}, but is kept for improved compiler performance.
      * If we just rely on {@link typeSchemaSymbol}, the compiler has to work much harder to distinguish schema in unions,
@@ -106,9 +105,8 @@ export interface WithType<out TName extends string = string, out TKind extends N
      *
      * This property is not intended for any use other than helping the compiler distinguish schema types,
      * and should not be referenced in any code other than internal to the tree package.
-     * @deprecated Use {@link typeSchemaSymbol} instead.
      */
-    get [typeNameSymbol](): TName;
+    get [schemaIdentifierBrand](): TName;
     /**
      * Type symbol, marking a type in a way to increase type safety via strong type checking.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"withType.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/withType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAAgC,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAkC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAoC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,QAAQ,CACxB,GAAG,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACjC,GAAG,CAAC,KAAK,SAAS,QAAQ,GAAG,QAAQ,EACrC,GAAG,CAAC,KAAK,GAAG,OAAO;IAEnB;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,cAAc,CAAC,IAAI,KAAK,CAAC;IAE9B;;OAEG;IACH,IAAI,CAAC,gBAAgB,CAAC,IAAI,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;CAC7F"}
+{"version":3,"file":"withType.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/withType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,OAAO,MAAmD,CAAC;AAE/F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAkC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAoC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,QAAQ,CACxB,GAAG,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACjC,GAAG,CAAC,KAAK,SAAS,QAAQ,GAAG,QAAQ,EACrC,GAAG,CAAC,KAAK,GAAG,OAAO;IAEnB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,qBAAqB,CAAC,IAAI,KAAK,CAAC;IAErC;;OAEG;IACH,IAAI,CAAC,gBAAgB,CAAC,IAAI,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;CAC7F"}

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

@@ -4,25 +4,24 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.contentSchemaSymbol = exports.typeSchemaSymbol = exports.typeNameSymbol = void 0;
+exports.contentSchemaSymbol = exports.typeSchemaSymbol = exports.schemaIdentifierBrand = void 0;
 /**
  * An internal brand to improve compiler performance.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  * @privateRemarks
  * The identifier of a {@link TreeNode}'s schema.
  * This allows the type checker to distinguish different node types more efficiently than via {@link typeSchemaSymbol}.
- * @deprecated External code should use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.
  * @system @public
  */
-exports.typeNameSymbol = Symbol("TreeNode Type");
+exports.schemaIdentifierBrand = Symbol("TreeNode Schema Identifier Brand");
 /**
  * The type of a {@link TreeNode}.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
  * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  *
  * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.
  * Instead construct a real node of the desired type using its constructor.

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

@@ -1 +1 @@
-{"version":3,"file":"withType.js","sourceRoot":"","sources":["../../../src/simple-tree/core/withType.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AASH;;;;;;;;;;GAUG;AACU,QAAA,cAAc,GAAkB,MAAM,CAAC,eAAe,CAAC,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACU,QAAA,gBAAgB,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,mBAAmB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Used by doc links:\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports\nimport type { TreeAlpha } from \"../../shared-tree/index.js\";\n\nimport type { TreeNode } from \"./treeNode.js\";\nimport type { NodeKind, TreeNodeSchemaClass } from \"./treeNodeSchema.js\";\n\n/**\n * An internal brand to improve compiler performance.\n * For more information about the type, use `Tree.schema(theNode)` instead.\n * @remarks\n * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.\n * @privateRemarks\n * The identifier of a {@link TreeNode}'s schema.\n * This allows the type checker to distinguish different node types more efficiently than via {@link typeSchemaSymbol}.\n * @deprecated External code should use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.\n * @system @public\n */\nexport const typeNameSymbol: unique symbol = Symbol(\"TreeNode Type\");\n\n/**\n * The type of a {@link TreeNode}.\n * For more information about the type, use `Tree.schema(theNode)` instead.\n * @remarks\n * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.\n * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.\n *\n * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.\n * Instead construct a real node of the desired type using its constructor.\n *\n * This symbol should not be used directly for type narrowing. Instead use {@link WithType}.\n * @privateRemarks\n * This prevents non-nodes from being accidentally used as nodes and allows the type-checker to distinguish different node types.\n * @system @public\n */\nexport const typeSchemaSymbol: unique symbol = Symbol(\"TreeNode Schema\");\n\n/**\n * The intended type of insertable content that is to become a {@link TreeNode}.\n * @remarks Use the type-safe {@link (TreeAlpha:interface).tagContentSchema} function to tag insertable content with this symbol.\n *\n * If a property with this symbol key is present on an object that is inserted into the tree,\n * the tree will use the schema identifier specified by the value of this property when creating the node.\n * This is particularly useful for specifying the intended schema of untyped content when it would otherwise be ambiguous.\n * @example\n * ```typescript\n * const sf = new SchemaFactory(\"example\");\n * class Dog extends sf.object(\"Dog\", { name: sf.string() }) {}\n * class Cat extends sf.object(\"Cat\", { name: sf.string() }) {}\n * class Root extends sf.object(\"Root\", { pet: [Dog, Cat] }) {}\n * // ...\n * view.root.pet = { name: \"Max\" }; // Error: ambiguous schema - is it a Dog or a Cat?\n * view.root.pet = { name: \"Max\", [contentSchemaSymbol]: \"example.Dog\" }; // No error - it's a Dog.\n * ```\n * @alpha\n */\nexport const contentSchemaSymbol: unique symbol = Symbol(\"SharedTree Schema\");\n\n/**\n * Adds a type symbol to a type for stronger typing.\n *\n * @typeParam TName - Same as {@link TreeNodeSchema}'s \"Name\" parameter.\n * @typeParam TKind - Same as {@link TreeNodeSchema}'s \"Kind\" parameter.\n * @typeParam TInfo - Same as {@link TreeNodeSchema}'s \"Info\" parameter: format depends on the Kind.\n * @remarks\n * Powers {@link TreeNode}'s strong typing setup.\n * @example Narrow types for overloading based on NodeKind\n * ```typescript\n * function getKeys(node: TreeNode & WithType<string, NodeKind.Array>): number[];\n * function getKeys(node: TreeNode & WithType<string, NodeKind.Map | NodeKind.Object>): string[];\n * function getKeys(node: TreeNode): string[] | number[];\n * function getKeys(node: TreeNode): string[] | number[] {\n * \tconst schema = Tree.schema(node);\n * \tswitch (schema.kind) {\n * \t\tcase NodeKind.Array: {\n * \t\t\tconst arrayNode = node as TreeArrayNode;\n * \t\t\tconst keys: number[] = [];\n * \t\t\tfor (let index = 0; index < arrayNode.length; index++) {\n * \t\t\t\tkeys.push(index);\n * \t\t\t}\n * \t\t\treturn keys;\n * \t\t}\n * \t\tcase NodeKind.Map:\n * \t\t\treturn [...(node as TreeMapNode).keys()];\n * \t\tcase NodeKind.Object:\n * \t\t\treturn Object.keys(node);\n * \t\tdefault:\n * \t\t\tthrow new Error(\"Unsupported Kind\");\n * \t}\n * }\n * ```\n * @privateRemarks\n * The properties of this are implemented as getters rather than instance properties as that is the easiest way to make them non-enumerable,\n * and also saves memory and time as they only have to be setup on the prototype.\n * These being non-enumerable inherited properties minimizes impact on users,\n * hiding them from things like `Reflect.ownKeys`, Object spread, `Object.getOwnPropertyDescriptors`, and `for...in` loops.\n * How we declare them here actually doesn't impact that,\n * but is a good way to communicate to users and internal devs that these should be implemented as inherited getters to accomplish the above.\n * @sealed @public\n */\nexport interface WithType<\n\tout TName extends string = string,\n\tout TKind extends NodeKind = NodeKind,\n\tout TInfo = unknown,\n> {\n\t/**\n\t * Type symbol, marking a type in a way to increase type safety via strong type checking.\n\t *\n\t * Use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use `WithType` instead of the symbols directly.\n\t * @remarks\n\t * This should be redundant with {@link typeSchemaSymbol}, but is kept for improved compiler performance.\n\t * If we just rely on {@link typeSchemaSymbol}, the compiler has to work much harder to distinguish schema in unions,\n\t * which can cause large schema unions to hit \"error TS2859: Excessive complexity comparing types\".\n\t *\n\t * This property is not intended for any use other than helping the compiler distinguish schema types,\n\t * and should not be referenced in any code other than internal to the tree package.\n\t * @deprecated Use {@link typeSchemaSymbol} instead.\n\t */\n\tget [typeNameSymbol](): TName;\n\n\t/**\n\t * Type symbol, marking a type in a way to increase type safety via strong type checking.\n\t */\n\tget [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode, never, boolean, TInfo>;\n}\n"]}
+{"version":3,"file":"withType.js","sourceRoot":"","sources":["../../../src/simple-tree/core/withType.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAQH;;;;;;;;;GASG;AACU,QAAA,qBAAqB,GAAkB,MAAM,CAAC,kCAAkC,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;GAcG;AACU,QAAA,gBAAgB,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,mBAAmB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports -- Imported only for documentation links.\nimport type { TreeAlpha } from \"../../shared-tree/index.js\";\n\nimport type { TreeNode } from \"./treeNode.js\";\nimport type { NodeKind, TreeNodeSchemaClass } from \"./treeNodeSchema.js\";\n\n/**\n * An internal brand to improve compiler performance.\n * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.\n * @remarks\n * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.\n * @privateRemarks\n * The identifier of a {@link TreeNode}'s schema.\n * This allows the type checker to distinguish different node types more efficiently than via {@link typeSchemaSymbol}.\n * @system @public\n */\nexport const schemaIdentifierBrand: unique symbol = Symbol(\"TreeNode Schema Identifier Brand\");\n\n/**\n * The type of a {@link TreeNode}.\n * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.\n * @remarks\n * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.\n * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.\n *\n * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.\n * Instead construct a real node of the desired type using its constructor.\n *\n * This symbol should not be used directly for type narrowing. Instead use {@link WithType}.\n * @privateRemarks\n * This prevents non-nodes from being accidentally used as nodes and allows the type-checker to distinguish different node types.\n * @system @public\n */\nexport const typeSchemaSymbol: unique symbol = Symbol(\"TreeNode Schema\");\n\n/**\n * The intended type of insertable content that is to become a {@link TreeNode}.\n * @remarks Use the type-safe {@link (TreeAlpha:interface).tagContentSchema} function to tag insertable content with this symbol.\n *\n * If a property with this symbol key is present on an object that is inserted into the tree,\n * the tree will use the schema identifier specified by the value of this property when creating the node.\n * This is particularly useful for specifying the intended schema of untyped content when it would otherwise be ambiguous.\n * @example\n * ```typescript\n * const sf = new SchemaFactory(\"example\");\n * class Dog extends sf.object(\"Dog\", { name: sf.string() }) {}\n * class Cat extends sf.object(\"Cat\", { name: sf.string() }) {}\n * class Root extends sf.object(\"Root\", { pet: [Dog, Cat] }) {}\n * // ...\n * view.root.pet = { name: \"Max\" }; // Error: ambiguous schema - is it a Dog or a Cat?\n * view.root.pet = { name: \"Max\", [contentSchemaSymbol]: \"example.Dog\" }; // No error - it's a Dog.\n * ```\n * @alpha\n */\nexport const contentSchemaSymbol: unique symbol = Symbol(\"SharedTree Schema\");\n\n/**\n * Adds a type symbol to a type for stronger typing.\n *\n * @typeParam TName - Same as {@link TreeNodeSchema}'s \"Name\" parameter.\n * @typeParam TKind - Same as {@link TreeNodeSchema}'s \"Kind\" parameter.\n * @typeParam TInfo - Same as {@link TreeNodeSchema}'s \"Info\" parameter: format depends on the Kind.\n * @remarks\n * Powers {@link TreeNode}'s strong typing setup.\n * @example Narrow types for overloading based on NodeKind\n * ```typescript\n * function getKeys(node: TreeNode & WithType<string, NodeKind.Array>): number[];\n * function getKeys(node: TreeNode & WithType<string, NodeKind.Map | NodeKind.Object>): string[];\n * function getKeys(node: TreeNode): string[] | number[];\n * function getKeys(node: TreeNode): string[] | number[] {\n * \tconst schema = Tree.schema(node);\n * \tswitch (schema.kind) {\n * \t\tcase NodeKind.Array: {\n * \t\t\tconst arrayNode = node as TreeArrayNode;\n * \t\t\tconst keys: number[] = [];\n * \t\t\tfor (let index = 0; index < arrayNode.length; index++) {\n * \t\t\t\tkeys.push(index);\n * \t\t\t}\n * \t\t\treturn keys;\n * \t\t}\n * \t\tcase NodeKind.Map:\n * \t\t\treturn [...(node as TreeMapNode).keys()];\n * \t\tcase NodeKind.Object:\n * \t\t\treturn Object.keys(node);\n * \t\tdefault:\n * \t\t\tthrow new Error(\"Unsupported Kind\");\n * \t}\n * }\n * ```\n * @privateRemarks\n * The properties of this are implemented as getters rather than instance properties as that is the easiest way to make them non-enumerable,\n * and also saves memory and time as they only have to be setup on the prototype.\n * These being non-enumerable inherited properties minimizes impact on users,\n * hiding them from things like `Reflect.ownKeys`, Object spread, `Object.getOwnPropertyDescriptors`, and `for...in` loops.\n * How we declare them here actually doesn't impact that,\n * but is a good way to communicate to users and internal devs that these should be implemented as inherited getters to accomplish the above.\n * @sealed @public\n */\nexport interface WithType<\n\tout TName extends string = string,\n\tout TKind extends NodeKind = NodeKind,\n\tout TInfo = unknown,\n> {\n\t/**\n\t * Type symbol, marking a type in a way to increase type safety via strong type checking.\n\t *\n\t * Use {@link TreeNodeApi.schema | Tree.schema(theNode)} for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.\n\t * @remarks\n\t * This should be redundant with {@link typeSchemaSymbol}, but is kept for improved compiler performance.\n\t * If we just rely on {@link typeSchemaSymbol}, the compiler has to work much harder to distinguish schema in unions,\n\t * which can cause large schema unions to hit \"error TS2859: Excessive complexity comparing types\".\n\t *\n\t * This property is not intended for any use other than helping the compiler distinguish schema types,\n\t * and should not be referenced in any code other than internal to the tree package.\n\t */\n\tget [schemaIdentifierBrand](): TName;\n\n\t/**\n\t * Type symbol, marking a type in a way to increase type safety via strong type checking.\n\t */\n\tget [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode, never, boolean, TInfo>;\n}\n"]}

package/dist/simple-tree/createContext.js

@@ -4,7 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTreeNodeSchemaInitializedData = exports.getUnhydratedContext = void 0;
+exports.getUnhydratedContext = getUnhydratedContext;
+exports.getTreeNodeSchemaInitializedData = getTreeNodeSchemaInitializedData;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../feature-libraries/index.js");
 const index_js_2 = require("../util/index.js");
@@ -38,7 +39,6 @@ function getUnhydratedContext(schema) {
         getUnhydratedContextIsRunning = false;
     }
 }
-exports.getUnhydratedContext = getUnhydratedContext;
 /**
  * Utility for creating {@link TreeNodeSchemaInitializedData}.
  */
@@ -50,5 +50,4 @@ function getTreeNodeSchemaInitializedData(schema, handler) {
         childAllowedTypes: data.childAllowedTypes.map((t) => t.evaluate()),
     };
 }
-exports.getTreeNodeSchemaInitializedData = getTreeNodeSchemaInitializedData;
 //# sourceMappingURL=createContext.js.map

package/dist/simple-tree/createContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"createContext.js","sourceRoot":"","sources":["../../src/simple-tree/createContext.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAE7D,4DAAoE;AACpE,+CAA+C;AAE/C,8CAMyB;AACzB,qDAAkF;AAClF,2DAAyE;AAEzE,MAAM,YAAY,GAA0C,IAAI,OAAO,EAAE,CAAC;AAE1E;;GAEG;AACH,IAAI,6BAA6B,GAAG,KAAK,CAAC;AAE1C;;;;GAIG;AACH,SAAgB,oBAAoB,CAAC,MAA2B;IAC/D,6DAA6D;IAC7D,8IAA8I;IAC9I,2FAA2F;IAC3F,IAAA,iBAAM,EACL,CAAC,6BAA6B,EAC9B,KAAK,CAAC,kDAAkD,CACxD,CAAC;IACF,6BAA6B,GAAG,IAAI,CAAC;IACrC,IAAI,CAAC;QACJ,OAAO,IAAA,sBAAW,EAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;YAC9C,MAAM,UAAU,GAAG,IAAA,qCAAoB,EAAC,MAAM,CAAC,CAAC;YAEhD,MAAM,WAAW,GAAG,IAAI,4BAAiB,CACxC,8BAAmB,EACnB,IAAA,kCAAc,EAAC,MAAM,EAAE,sCAAkB,CAAC,CAC1C,CAAC;YACF,OAAO,IAAI,kBAAO,CACjB,WAAW,EACX,kBAAO,CAAC,uBAAuB,CAAC,UAAU,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CACvE,CAAC;QACH,CAAC,CAAC,CAAC;IACJ,CAAC;YAAS,CAAC;QACV,6BAA6B,GAAG,KAAK,CAAC;IACvC,CAAC;AACF,CAAC;AAzBD,oDAyBC;AAED;;GAEG;AACH,SAAgB,gCAAgC,CAC/C,MAAsB,EACtB,OAA0F;IAE1F,MAAM,IAAI,GAAG,IAAA,uCAA4B,EAAC,MAAM,CAAC,CAAC;IAClD,OAAO;QACN,GAAG,OAAO;QACV,OAAO,EAAE,oBAAoB,CAAC,MAAM,CAAC;QACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;KAClE,CAAC;AACH,CAAC;AAVD,4EAUC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { defaultSchemaPolicy } from \"../feature-libraries/index.js\";\nimport { getOrCreate } from \"../util/index.js\";\n\nimport {\n\tContext,\n\tgetTreeNodeSchemaPrivateData,\n\tUnhydratedContext,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaInitializedData,\n} from \"./core/index.js\";\nimport { normalizeFieldSchema, type ImplicitFieldSchema } from \"./fieldSchema.js\";\nimport { toStoredSchema, toUnhydratedSchema } from \"./toStoredSchema.js\";\n\nconst contextCache: WeakMap<ImplicitFieldSchema, Context> = new WeakMap();\n\n/**\n * See note in {@link getUnhydratedContext}.\n */\nlet getUnhydratedContextIsRunning = false;\n\n/**\n * Utility for creating {@link Context}s for unhydrated nodes.\n * @remarks\n * The resulting context will not allow any unknown optional fields.\n */\nexport function getUnhydratedContext(schema: ImplicitFieldSchema): Context {\n\t// Due to caching, calling this reentrantly can cause issues.\n\t// Due to recursive schema, and generally lots of lazy initialization code depending on this, bugs with this going reentrant are not uncommon.\n\t// To make debugging such cases much easier, we assert that this is not called reentrantly.\n\tassert(\n\t\t!getUnhydratedContextIsRunning,\n\t\t0xca7 /* getUnhydratedContext should not be reentrant */,\n\t);\n\tgetUnhydratedContextIsRunning = true;\n\ttry {\n\t\treturn getOrCreate(contextCache, schema, (s) => {\n\t\t\tconst normalized = normalizeFieldSchema(schema);\n\n\t\t\tconst flexContext = new UnhydratedContext(\n\t\t\t\tdefaultSchemaPolicy,\n\t\t\t\ttoStoredSchema(schema, toUnhydratedSchema),\n\t\t\t);\n\t\t\treturn new Context(\n\t\t\t\tflexContext,\n\t\t\t\tContext.schemaMapFromRootSchema(normalized.allowedTypesFull.evaluate()),\n\t\t\t);\n\t\t});\n\t} finally {\n\t\tgetUnhydratedContextIsRunning = false;\n\t}\n}\n\n/**\n * Utility for creating {@link TreeNodeSchemaInitializedData}.\n */\nexport function getTreeNodeSchemaInitializedData(\n\tschema: TreeNodeSchema,\n\thandler: Pick<TreeNodeSchemaInitializedData, \"toFlexContent\" | \"shallowCompatibilityTest\">,\n): TreeNodeSchemaInitializedData {\n\tconst data = getTreeNodeSchemaPrivateData(schema);\n\treturn {\n\t\t...handler,\n\t\tcontext: getUnhydratedContext(schema),\n\t\tchildAllowedTypes: data.childAllowedTypes.map((t) => t.evaluate()),\n\t};\n}\n"]}
+{"version":3,"file":"createContext.js","sourceRoot":"","sources":["../../src/simple-tree/createContext.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AA6BH,oDAyBC;AAKD,4EAUC;AAnED,kEAA6D;AAE7D,4DAAoE;AACpE,+CAA+C;AAE/C,8CAMyB;AACzB,qDAAkF;AAClF,2DAAyE;AAEzE,MAAM,YAAY,GAA0C,IAAI,OAAO,EAAE,CAAC;AAE1E;;GAEG;AACH,IAAI,6BAA6B,GAAG,KAAK,CAAC;AAE1C;;;;GAIG;AACH,SAAgB,oBAAoB,CAAC,MAA2B;IAC/D,6DAA6D;IAC7D,8IAA8I;IAC9I,2FAA2F;IAC3F,IAAA,iBAAM,EACL,CAAC,6BAA6B,EAC9B,KAAK,CAAC,kDAAkD,CACxD,CAAC;IACF,6BAA6B,GAAG,IAAI,CAAC;IACrC,IAAI,CAAC;QACJ,OAAO,IAAA,sBAAW,EAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;YAC9C,MAAM,UAAU,GAAG,IAAA,qCAAoB,EAAC,MAAM,CAAC,CAAC;YAEhD,MAAM,WAAW,GAAG,IAAI,4BAAiB,CACxC,8BAAmB,EACnB,IAAA,kCAAc,EAAC,MAAM,EAAE,sCAAkB,CAAC,CAC1C,CAAC;YACF,OAAO,IAAI,kBAAO,CACjB,WAAW,EACX,kBAAO,CAAC,uBAAuB,CAAC,UAAU,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CACvE,CAAC;QACH,CAAC,CAAC,CAAC;IACJ,CAAC;YAAS,CAAC;QACV,6BAA6B,GAAG,KAAK,CAAC;IACvC,CAAC;AACF,CAAC;AAED;;GAEG;AACH,SAAgB,gCAAgC,CAC/C,MAAsB,EACtB,OAA0F;IAE1F,MAAM,IAAI,GAAG,IAAA,uCAA4B,EAAC,MAAM,CAAC,CAAC;IAClD,OAAO;QACN,GAAG,OAAO;QACV,OAAO,EAAE,oBAAoB,CAAC,MAAM,CAAC;QACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;KAClE,CAAC;AACH,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { defaultSchemaPolicy } from \"../feature-libraries/index.js\";\nimport { getOrCreate } from \"../util/index.js\";\n\nimport {\n\tContext,\n\tgetTreeNodeSchemaPrivateData,\n\tUnhydratedContext,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaInitializedData,\n} from \"./core/index.js\";\nimport { normalizeFieldSchema, type ImplicitFieldSchema } from \"./fieldSchema.js\";\nimport { toStoredSchema, toUnhydratedSchema } from \"./toStoredSchema.js\";\n\nconst contextCache: WeakMap<ImplicitFieldSchema, Context> = new WeakMap();\n\n/**\n * See note in {@link getUnhydratedContext}.\n */\nlet getUnhydratedContextIsRunning = false;\n\n/**\n * Utility for creating {@link Context}s for unhydrated nodes.\n * @remarks\n * The resulting context will not allow any unknown optional fields.\n */\nexport function getUnhydratedContext(schema: ImplicitFieldSchema): Context {\n\t// Due to caching, calling this reentrantly can cause issues.\n\t// Due to recursive schema, and generally lots of lazy initialization code depending on this, bugs with this going reentrant are not uncommon.\n\t// To make debugging such cases much easier, we assert that this is not called reentrantly.\n\tassert(\n\t\t!getUnhydratedContextIsRunning,\n\t\t0xca7 /* getUnhydratedContext should not be reentrant */,\n\t);\n\tgetUnhydratedContextIsRunning = true;\n\ttry {\n\t\treturn getOrCreate(contextCache, schema, (s) => {\n\t\t\tconst normalized = normalizeFieldSchema(schema);\n\n\t\t\tconst flexContext = new UnhydratedContext(\n\t\t\t\tdefaultSchemaPolicy,\n\t\t\t\ttoStoredSchema(schema, toUnhydratedSchema),\n\t\t\t);\n\t\t\treturn new Context(\n\t\t\t\tflexContext,\n\t\t\t\tContext.schemaMapFromRootSchema(normalized.allowedTypesFull.evaluate()),\n\t\t\t);\n\t\t});\n\t} finally {\n\t\tgetUnhydratedContextIsRunning = false;\n\t}\n}\n\n/**\n * Utility for creating {@link TreeNodeSchemaInitializedData}.\n */\nexport function getTreeNodeSchemaInitializedData(\n\tschema: TreeNodeSchema,\n\thandler: Pick<TreeNodeSchemaInitializedData, \"toFlexContent\" | \"shallowCompatibilityTest\">,\n): TreeNodeSchemaInitializedData {\n\tconst data = getTreeNodeSchemaPrivateData(schema);\n\treturn {\n\t\t...handler,\n\t\tcontext: getUnhydratedContext(schema),\n\t\tchildAllowedTypes: data.childAllowedTypes.map((t) => t.evaluate()),\n\t};\n}\n"]}

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

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

package/dist/simple-tree/fieldSchema.js

@@ -4,7 +4,16 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.areFieldSchemaEqual = exports.areImplicitFieldSchemaEqual = exports.normalizeFieldSchema = exports.FieldSchemaAlpha = exports.FieldSchema = exports.createFieldSchema = exports.getDefaultProvider = exports.extractFieldProvider = exports.isConstant = exports.getExplicitStoredKey = exports.getStoredKey = exports.FieldKind = void 0;
+exports.FieldSchemaAlpha = exports.FieldSchema = exports.FieldKind = void 0;
+exports.getStoredKey = getStoredKey;
+exports.getExplicitStoredKey = getExplicitStoredKey;
+exports.isConstant = isConstant;
+exports.extractFieldProvider = extractFieldProvider;
+exports.getDefaultProvider = getDefaultProvider;
+exports.createFieldSchema = createFieldSchema;
+exports.normalizeFieldSchema = normalizeFieldSchema;
+exports.areImplicitFieldSchemaEqual = areImplicitFieldSchemaEqual;
+exports.areFieldSchemaEqual = areFieldSchemaEqual;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../util/index.js");
@@ -50,7 +59,6 @@ var FieldKind;
 function getStoredKey(propertyKey, fieldSchema) {
     return (0, index_js_1.brand)(getExplicitStoredKey(fieldSchema) ?? propertyKey);
 }
-exports.getStoredKey = getStoredKey;
 /**
  * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
  * Otherwise, returns undefined.
@@ -58,26 +66,21 @@ exports.getStoredKey = getStoredKey;
 function getExplicitStoredKey(fieldSchema) {
     return fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;
 }
-exports.getExplicitStoredKey = getExplicitStoredKey;
 /**
  * Returns true if the given {@link FieldProvider} is a {@link ConstantFieldProvider}
  */
 function isConstant(fieldProvider) {
     return fieldProvider.length === 0;
 }
-exports.isConstant = isConstant;
 function extractFieldProvider(input) {
     return input;
 }
-exports.extractFieldProvider = extractFieldProvider;
 function getDefaultProvider(input) {
     return input;
 }
-exports.getDefaultProvider = getDefaultProvider;
 function createFieldSchema(kind, annotatedTypes, props) {
     return createFieldSchemaPrivate(kind, annotatedTypes, props);
 }
-exports.createFieldSchema = createFieldSchema;
 /**
  * Implementation for {@link createFieldSchema}
  */
@@ -101,6 +104,15 @@ let createFieldSchemaPrivate;
  * @sealed @public
  */
 class FieldSchema {
+    kind;
+    allowedTypes;
+    props;
+    /**
+     * This class is used with instanceof, and therefore should have nominal typing.
+     * This field enforces that.
+     */
+    _typeCheck;
+    lazyTypes;
     /**
      * What types of tree nodes are allowed in this field.
      * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.
@@ -108,6 +120,10 @@ class FieldSchema {
     get allowedTypeSet() {
         return this.lazyTypes.value;
     }
+    /**
+     * True if and only if, when constructing a node with this field, a value must be provided for it.
+     */
+    requiresValue;
     /**
      * {@inheritDoc FieldProps.metadata}
      */
@@ -152,12 +168,22 @@ exports.FieldSchema = FieldSchema;
  * @sealed @alpha
  */
 class FieldSchemaAlpha extends FieldSchema {
+    propsAlpha;
     get persistedMetadata() {
         return this.propsAlpha?.persistedMetadata;
     }
     get isStagedOptional() {
         return this.propsAlpha?.stagedOptionalUpgrade ?? false;
     }
+    static {
+        createFieldSchemaPrivate = (kind, annotatedAllowedTypes, props) => 
+        // TCustomMetadata2 requires type assertion due to limitations with dependent type parameters
+        new FieldSchemaAlpha(kind, annotatedAllowedTypes, props);
+    }
+    /**
+     * {@link normalizeAllowedTypes|Normalized} version of {@link FieldSchema.allowedTypes}.
+     */
+    allowedTypesFull;
     get allowedTypesIdentifiers() {
         return this.allowedTypesFull.evaluateIdentifiers();
     }
@@ -172,11 +198,6 @@ class FieldSchemaAlpha extends FieldSchema {
     }
 }
 exports.FieldSchemaAlpha = FieldSchemaAlpha;
-(() => {
-    createFieldSchemaPrivate = (kind, annotatedAllowedTypes, props) => 
-    // TCustomMetadata2 requires type assertion due to limitations with dependent type parameters
-    new FieldSchemaAlpha(kind, annotatedAllowedTypes, props);
-})();
 /**
  * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitFieldSchema} to a {@link FieldSchema}.
  * @internal
@@ -186,7 +207,6 @@ function normalizeFieldSchema(schema) {
         ? schema
         : createFieldSchema(FieldKind.Required, schema);
 }
-exports.normalizeFieldSchema = normalizeFieldSchema;
 /**
  * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.
  * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:
@@ -200,7 +220,6 @@ exports.normalizeFieldSchema = normalizeFieldSchema;
 function areImplicitFieldSchemaEqual(a, b) {
     return areFieldSchemaEqual(normalizeFieldSchema(a), normalizeFieldSchema(b));
 }
-exports.areImplicitFieldSchemaEqual = areImplicitFieldSchemaEqual;
 /**
  * Returns true if the given {@link FieldSchema} are equivalent, otherwise false.
  * @remarks Two FieldSchema are considered equivalent if all of the following are true:
@@ -220,7 +239,6 @@ function areFieldSchemaEqual(a, b) {
     }
     return (0, index_js_1.compareSets)({ a: a.allowedTypeSet, b: b.allowedTypeSet });
 }
-exports.areFieldSchemaEqual = areFieldSchemaEqual;
 /**
  * Returns true if the given {@link FieldProps} are equivalent, otherwise false.
  * @remarks FieldProps are considered equivalent if their keys and default providers are reference equal, and their metadata are {@link areMetadataEqual | equivalent}.

package/dist/simple-tree/fieldSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"fieldSchema.js","sourceRoot":"","sources":["../../src/simple-tree/fieldSchema.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 { ErasedType } from \"@fluidframework/core-interfaces\";\nimport { Lazy } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport type { FieldKey } from \"../core/index.js\";\nimport type { FlexTreeHydratedContextMinimal } from \"../feature-libraries/index.js\";\nimport {\n\ttype MakeNominal,\n\tbrand,\n\ttype UnionToIntersection,\n\tcompareSets,\n\ttype requireTrue,\n\ttype areOnlyKeys,\n\ttype JsonCompatibleReadOnlyObject,\n} from \"../util/index.js\";\n\nimport type {\n\tTreeNodeSchema,\n\tTreeNode,\n\tUnhydratedFlexTreeNode,\n\tImplicitAllowedTypes,\n\tTreeNodeFromImplicitAllowedTypes,\n\tTreeLeafValue,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tAllowedTypesFull,\n\tSchemaUpgrade,\n} from \"./core/index.js\";\nimport { AnnotatedAllowedTypesInternal, normalizeAllowedTypes } from \"./core/index.js\";\nimport type {\n\tSchemaType,\n\tSimpleAllowedTypeAttributes,\n\tSimpleFieldSchema,\n} from \"./simpleSchema.js\";\nimport type { InsertableContent } from \"./unhydratedFlexTreeFromInsertable.js\";\nimport type { UnsafeUnknownSchema } from \"./unsafeUnknownSchema.js\";\n\n/**\n * Kind of a field on an {@link TreeObjectNode}.\n * @remarks\n * More kinds may be added over time, so do not assume this is an exhaustive set.\n * See {@link FieldSchema} for where these are used, and {@link SchemaFactory} for how to create schema which use them.\n * @public\n */\nexport enum FieldKind {\n\t/**\n\t * A field which can be empty or filled.\n\t * @remarks\n\t * Allows 0 or one child.\n\t */\n\tOptional,\n\t/**\n\t * A field which must always be filled.\n\t * @remarks\n\t * Only allows exactly one child.\n\t */\n\tRequired,\n\t/**\n\t * A special readonly field used for node identifier strings.\n\t * @remarks\n\t * Only allows exactly one child.\n\t *\n\t * See {@link SchemaFactory.identifier} for more details.\n\t */\n\tIdentifier,\n}\n\n/**\n * Maps from a property key to its corresponding {@link FieldProps.key | stored key} for the provided\n * {@link ImplicitFieldSchema | field schema}.\n *\n * @remarks\n * If an explicit stored key was specified in the schema, it will be used.\n * Otherwise, the stored key is the same as the property key.\n */\nexport function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {\n\treturn brand(getExplicitStoredKey(fieldSchema) ?? propertyKey);\n}\n\n/**\n * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.\n * Otherwise, returns undefined.\n */\nexport function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {\n\treturn fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;\n}\n\n/**\n * Additional information to provide to a {@link FieldSchema}.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @public\n */\nexport interface FieldProps<TCustomMetadata = unknown> {\n\t/**\n\t * The unique identifier of a field, used in the persisted form of the tree.\n\t *\n\t * @remarks\n\t * If not explicitly set via the schema, this is the same as the schema's property key.\n\t *\n\t * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.\n\t * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,\n\t * you can change the property key and specify the previous property key as the stored key.\n\t *\n\t * Notes:\n\t *\n\t * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`\n\t * will always return the property keys specified in the schema, ignoring any stored keys that differ from\n\t * the property keys.\n\t *\n\t * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys\n\t * (accounting for those implicitly derived from property keys) contains no duplicates.\n\t * This is validated at runtime.\n\t *\n\t * @example Refactoring code without breaking compatibility with existing data\n\t *\n\t * Consider some existing object schema:\n\t *\n\t * ```TypeScript\n\t * class Point extends schemaFactory.object(\"Point\", {\n\t * \txPosition: schemaFactory.number,\n\t * \tyPosition: schemaFactory.number,\n\t * \tzPosition: schemaFactory.optional(schemaFactory.number),\n\t * });\n\t * ```\n\t *\n\t * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.\n\t *\n\t * We would like to refactor the schema to omit \"Position\" from the property keys, but application data has\n\t * already been persisted using the original property keys. To maintain compatibility with existing data,\n\t * we can refactor the schema as follows:\n\t *\n\t * ```TypeScript\n\t * class Point extends schemaFactory.object(\"Point\", {\n\t * \tx: schemaFactory.required(schemaFactory.number, { key: \"xPosition\" }),\n\t * \ty: schemaFactory.required(schemaFactory.number, { key: \"yPosition\" }),\n\t * \tz: schemaFactory.optional(schemaFactory.number, { key: \"zPosition\" }),\n\t * });\n\t * ```\n\t *\n\t * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.\n\t *\n\t * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.\n\t */\n\treadonly key?: string;\n\n\t/**\n\t * A default provider used for fields which were not provided any values.\n\t * @privateRemarks\n\t * We are using an erased type here, as we want to expose this API but `InsertableContent` and `NodeKeyManager` are not public.\n\t */\n\treadonly defaultProvider?: DefaultProvider;\n\n\t/**\n\t * Optional metadata to associate with the field.\n\t *\n\t * @remarks\n\t * Note: this metadata is not persisted nor made part of the collaborative state; it is strictly client-local.\n\t * Different clients in the same collaborative session may see different metadata for the same field.\n\t */\n\treadonly metadata?: FieldSchemaMetadata<TCustomMetadata>;\n}\n\n/**\n * {@link FieldProps} extended with additional `alpha` options.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @alpha @input\n */\nexport interface FieldPropsAlpha<TCustomMetadata = unknown>\n\textends FieldProps<TCustomMetadata> {\n\t/**\n\t * The persisted metadata for a field schema.\n\t * @remarks\n\t * Sets {@link SimpleFieldSchema.persistedMetadata}.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n\n\t/**\n\t * If defined, indicates that this field is a {@link SchemaStaticsAlpha.stagedOptional | staged optional} field.\n\t */\n\treadonly stagedOptionalUpgrade?: SchemaUpgrade;\n}\n\n/**\n * A {@link FieldProvider} which requires additional context in order to produce its content\n */\nexport type ContextualFieldProvider = (\n\tcontext: FlexTreeHydratedContextMinimal | \"UseGlobalContext\",\n) => UnhydratedFlexTreeNode[];\n/**\n * A {@link FieldProvider} which can produce its content in a vacuum.\n */\nexport type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];\n/**\n * A function which produces content for a field every time that it is called.\n */\nexport type FieldProvider = ContextualFieldProvider | ConstantFieldProvider;\n/**\n * Returns true if the given {@link FieldProvider} is a {@link ConstantFieldProvider}\n */\nexport function isConstant(\n\tfieldProvider: FieldProvider,\n): fieldProvider is ConstantFieldProvider {\n\treturn fieldProvider.length === 0;\n}\n\n/**\n * Provides a default value for a field.\n * @remarks\n * If present in a `FieldSchema`, when constructing new tree content that field can be omitted, and a default will be provided.\n * @system @sealed @public\n */\nexport interface DefaultProvider extends ErasedType<\"@fluidframework/tree.FieldProvider\"> {}\n\nexport function extractFieldProvider(input: DefaultProvider): FieldProvider {\n\treturn input as unknown as FieldProvider;\n}\n\nexport function getDefaultProvider(input: FieldProvider): DefaultProvider {\n\treturn input as unknown as DefaultProvider;\n}\n\n/**\n * Metadata associated with a {@link FieldSchema}.\n *\n * @remarks Specified via {@link FieldProps.metadata}.\n *\n * @sealed\n * @public\n */\nexport interface FieldSchemaMetadata<TCustomMetadata = unknown> {\n\t/**\n\t * User-defined metadata.\n\t */\n\treadonly custom?: TCustomMetadata;\n\n\t/**\n\t * The description of the field.\n\t *\n\t * @remarks\n\t *\n\t * If provided, will be used by the system in scenarios where a description of the field is useful.\n\t * E.g., when converting a field schema to {@link https://json-schema.org/ | JSON Schema}, this description will be\n\t * used as the `description` field.\n\t */\n\treadonly description?: string | undefined;\n}\n\n/**\n * Metadata associated with a {@link FieldSchema}. Includes fields used by alpha features.\n *\n * @remarks Specified via {@link FieldProps.metadata}.\n *\n * @sealed\n * @alpha\n */\nexport interface FieldSchemaMetadataAlpha<TCustomMetadata = unknown>\n\textends FieldSchemaMetadata<TCustomMetadata> {\n\t/**\n\t * The persisted metadata for this schema element.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n}\n\n/**\n * Package internal construction API.\n */\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n>(kind: Kind, annotatedTypes: Types): FieldSchemaAlpha<Kind, Types, TCustomMetadata>;\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n\tTProps extends FieldProps<TCustomMetadata> = FieldProps<TCustomMetadata>,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops: TProps,\n): FieldSchemaAlpha<Kind, Types, TCustomMetadata, TProps>;\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n): FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined> {\n\treturn createFieldSchemaPrivate(kind, annotatedTypes, props);\n}\n\n/**\n * Implementation for {@link createFieldSchema}\n */\nlet createFieldSchemaPrivate: <\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n) => FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined>;\n\n/**\n * All policy for a specific field,\n * including functionality that does not have to be kept consistent across versions or deterministic.\n *\n * This can include policy for how to use this schema for \"view\" purposes, and well as how to expose editing APIs.\n * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link SchemaStatics.optional}.\n * @privateRemarks\n * Public access to the constructor is removed to prevent creating expressible but unsupported (or not stable) configurations.\n * {@link createFieldSchema} can be used internally to create instances.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @remarks\n * All implementations of this are actually {@link FieldSchemaAlpha} which exposes some additional alpha APIs.\n *\n * @sealed @public\n */\nexport class FieldSchema<\n\tout Kind extends FieldKind = FieldKind,\n\tout Types extends ImplicitAllowedTypes = ImplicitAllowedTypes,\n\tout TCustomMetadata = unknown,\n> {\n\t/**\n\t * This class is used with instanceof, and therefore should have nominal typing.\n\t * This field enforces that.\n\t */\n\tprotected _typeCheck!: MakeNominal;\n\n\tprivate readonly lazyTypes: Lazy<ReadonlySet<TreeNodeSchema>>;\n\n\t/**\n\t * What types of tree nodes are allowed in this field.\n\t * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.\n\t */\n\tpublic get allowedTypeSet(): ReadonlySet<TreeNodeSchema> {\n\t\treturn this.lazyTypes.value;\n\t}\n\n\t/**\n\t * True if and only if, when constructing a node with this field, a value must be provided for it.\n\t */\n\tpublic readonly requiresValue: boolean;\n\n\t/**\n\t * {@inheritDoc FieldProps.metadata}\n\t */\n\tpublic get metadata(): FieldSchemaMetadata<TCustomMetadata> {\n\t\treturn this.props?.metadata ?? {};\n\t}\n\n\t/**\n\t * This class is `@sealed`: protected members like this constructor are for internal use only.\n\t * Use {@link SchemaFactory} to create the FieldSchema instances.\n\t */\n\tprotected constructor(\n\t\t/**\n\t\t * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.\n\t\t * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.\n\t\t */\n\t\tpublic readonly kind: Kind,\n\t\t/**\n\t\t * What types of tree nodes are allowed in this field.\n\t\t */\n\t\tpublic readonly allowedTypes: Types,\n\t\t/**\n\t\t * Optional properties associated with the field.\n\t\t */\n\t\tpublic readonly props?: FieldProps<TCustomMetadata>,\n\t) {\n\t\tif (!(this instanceof FieldSchemaAlpha)) {\n\t\t\tthrow new UsageError(\"FieldSchema is @sealed: sub-classing is not allowed.\");\n\t\t}\n\n\t\tthis.lazyTypes = new Lazy(() => normalizeAllowedTypes(this.allowedTypes).evaluateSet());\n\t\t// TODO: optional fields should (by default) get a default provider that returns undefined, removing the need to special case them here:\n\t\tthis.requiresValue =\n\t\t\tthis.props?.defaultProvider === undefined && this.kind !== FieldKind.Optional;\n\t}\n}\n\n/**\n * {@link FieldSchema} including alpha APIs (currently {@link SimpleFieldSchema}).\n * @remarks\n * This class will go away once the alpha APIs are stable and implemented by {@link FieldSchema}.\n * @sealed @alpha\n */\nexport class FieldSchemaAlpha<\n\t\tKind extends FieldKind = FieldKind,\n\t\tTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes,\n\t\tTCustomMetadata = unknown,\n\t\tTProps extends FieldPropsAlpha<TCustomMetadata> | undefined =\n\t\t\t| FieldPropsAlpha<TCustomMetadata>\n\t\t\t| undefined,\n\t>\n\textends FieldSchema<Kind, Types, TCustomMetadata>\n\timplements SimpleFieldSchema<SchemaType.View>\n{\n\tprivate readonly propsAlpha: TProps;\n\n\tpublic get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined {\n\t\treturn this.propsAlpha?.persistedMetadata;\n\t}\n\n\tpublic get isStagedOptional(): false | SchemaUpgrade {\n\t\treturn this.propsAlpha?.stagedOptionalUpgrade ?? false;\n\t}\n\n\tstatic {\n\t\tcreateFieldSchemaPrivate = <\n\t\t\tKind2 extends FieldKind,\n\t\t\tTypes2 extends ImplicitAllowedTypes,\n\t\t\tTCustomMetadata2,\n\t\t>(\n\t\t\tkind: Kind2,\n\t\t\tannotatedAllowedTypes: Types2,\n\t\t\tprops?: FieldPropsAlpha<TCustomMetadata2>,\n\t\t) =>\n\t\t\t// TCustomMetadata2 requires type assertion due to limitations with dependent type parameters\n\t\t\tnew FieldSchemaAlpha(kind, annotatedAllowedTypes, props) as unknown as FieldSchemaAlpha<\n\t\t\t\tKind2,\n\t\t\t\tTypes2,\n\t\t\t\tTCustomMetadata2\n\t\t\t>;\n\t}\n\n\t/**\n\t * {@link normalizeAllowedTypes|Normalized} version of {@link FieldSchema.allowedTypes}.\n\t */\n\tpublic readonly allowedTypesFull: AllowedTypesFull;\n\n\tpublic get allowedTypesIdentifiers(): ReadonlySet<string> {\n\t\treturn this.allowedTypesFull.evaluateIdentifiers();\n\t}\n\n\tpublic get simpleAllowedTypes(): ReadonlyMap<\n\t\tstring,\n\t\tSimpleAllowedTypeAttributes<SchemaType.View>\n\t> {\n\t\treturn AnnotatedAllowedTypesInternal.evaluateSimpleAllowedTypes(this.allowedTypesFull);\n\t}\n\n\tprotected constructor(\n\t\tkind: Kind,\n\t\ttypes: Types,\n\n\t\tprops?: FieldPropsAlpha<TCustomMetadata>,\n\t) {\n\t\tsuper(kind, types, props);\n\n\t\tconst normalizedTypes = normalizeAllowedTypes(types);\n\t\tthis.allowedTypesFull = normalizedTypes;\n\t\tthis.propsAlpha = props as TProps;\n\t}\n}\n\n/**\n * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitFieldSchema} to a {@link FieldSchema}.\n * @internal\n */\nexport function normalizeFieldSchema(\n\tschema: ImplicitFieldSchema | ImplicitFieldSchema,\n): FieldSchemaAlpha {\n\treturn schema instanceof FieldSchema\n\t\t? (schema as FieldSchemaAlpha)\n\t\t: createFieldSchema(FieldKind.Required, schema);\n}\n\n/**\n * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.\n * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:\n * 1. They have the same {@link FieldKind | kinds}.\n * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.\n * 3. They have the same exact set of allowed types. The allowed types must be (respectively) reference equal.\n *\n * For example, comparing an ImplicitFieldSchema that is a {@link TreeNodeSchema} to an ImplicitFieldSchema that is a {@link FieldSchema}\n * will return true if they are the same kind, the FieldSchema has exactly one allowed type (the TreeNodeSchema), and they have equivalent FieldProps.\n */\nexport function areImplicitFieldSchemaEqual(\n\ta: ImplicitFieldSchema,\n\tb: ImplicitFieldSchema,\n): boolean {\n\treturn areFieldSchemaEqual(normalizeFieldSchema(a), normalizeFieldSchema(b));\n}\n\n/**\n * Returns true if the given {@link FieldSchema} are equivalent, otherwise false.\n * @remarks Two FieldSchema are considered equivalent if all of the following are true:\n * 1. They have the same {@link FieldKind | kinds}.\n * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.\n * 3. They have the same exact set of allowed types. The allowed types must be reference equal.\n */\nexport function areFieldSchemaEqual(a: FieldSchema, b: FieldSchema): boolean {\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\tif (a.kind !== b.kind) {\n\t\treturn false;\n\t}\n\n\tif (!areFieldPropsEqual(a.props, b.props)) {\n\t\treturn false;\n\t}\n\n\treturn compareSets({ a: a.allowedTypeSet, b: b.allowedTypeSet });\n}\n\n/**\n * Returns true if the given {@link FieldProps} are equivalent, otherwise false.\n * @remarks FieldProps are considered equivalent if their keys and default providers are reference equal, and their metadata are {@link areMetadataEqual | equivalent}.\n */\nfunction areFieldPropsEqual(a: FieldProps | undefined, b: FieldProps | undefined): boolean {\n\t// If any new fields are added to FieldProps, this check will stop compiling as a reminder that this function needs to be updated.\n\ttype _keys = requireTrue<areOnlyKeys<FieldProps, \"key\" | \"defaultProvider\" | \"metadata\">>;\n\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\tif (a?.key !== b?.key || a?.defaultProvider !== b?.defaultProvider) {\n\t\treturn false;\n\t}\n\n\tif (!areMetadataEqual(a?.metadata, b?.metadata)) {\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n/**\n * Returns true if the given {@link FieldSchemaMetadata} are equivalent, otherwise false.\n * @remarks FieldSchemaMetadata are considered equivalent if their custom data and descriptions are (respectively) reference equal.\n */\nfunction areMetadataEqual(\n\ta: FieldSchemaMetadataAlpha | undefined,\n\tb: FieldSchemaMetadataAlpha | undefined,\n): boolean {\n\t// If any new fields are added to FieldSchemaMetadata, this check will stop compiling as a reminder that this function needs to be updated.\n\ttype _keys = requireTrue<\n\t\tareOnlyKeys<FieldSchemaMetadataAlpha, \"custom\" | \"description\" | \"persistedMetadata\">\n\t>;\n\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\treturn (\n\t\tObject.is(a?.custom, b?.custom) &&\n\t\ta?.description === b?.description &&\n\t\tarePersistedMetadataEqual(a?.persistedMetadata, b?.persistedMetadata)\n\t);\n}\n\n/**\n * Returns true if the given persisted metadata fields are equivalent, otherwise false.\n * @remarks\n * Currently only handles shallow equality in the case where the keys are in the same order. This is acceptable for current use cases.\n */\nfunction arePersistedMetadataEqual(\n\ta: JsonCompatibleReadOnlyObject | undefined,\n\tb: JsonCompatibleReadOnlyObject | undefined,\n): boolean {\n\tif (Object.is(a, b)) {\n\t\treturn true;\n\t}\n\n\tif (a === undefined || b === undefined) {\n\t\treturn false;\n\t}\n\n\t// Note that the key order matters. If `a` and `b` have the same content but the keys are in a different order,\n\t// this method will return false.\n\tconst aStringified = JSON.stringify(a);\n\tconst bStringified = JSON.stringify(b);\n\n\treturn aStringified === bStringified;\n}\n\n/**\n * Schema for a field of a tree node.\n * @remarks\n * Implicitly treats {@link ImplicitAllowedTypes} as a Required field of that type.\n * @public\n */\nexport type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;\n\n/**\n * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.\n *\n * @typeparam TSchema - When non-exact schema are provided this errors on the side of returning too general of a type (a conservative union of all possibilities).\n * This is ideal for \"output APIs\" - i.e. it converts the schema type to the runtime type that a user will _read_ from the tree.\n * Examples of such \"non-exact\" schema include `ImplicitFieldSchema`, `ImplicitAllowedTypes`, and  TypeScript unions of schema types.\n * @public\n */\nexport type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> =\n\tTSchema extends FieldSchema<infer Kind, infer Types>\n\t\t? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind>\n\t\t: TSchema extends ImplicitAllowedTypes\n\t\t\t? TreeNodeFromImplicitAllowedTypes<TSchema>\n\t\t\t: TreeNode | TreeLeafValue | undefined;\n\n/**\n * Type of content that can be inserted into the tree for a field of the given schema.\n *\n * @see {@link Input}\n *\n * @typeparam TSchemaInput - Schema to process.\n * @typeparam TSchema - Do not specify: default value used as implementation detail.\n * @public\n */\nexport type InsertableTreeFieldFromImplicitField<\n\tTSchemaInput extends ImplicitFieldSchema,\n\tTSchema = UnionToIntersection<TSchemaInput>,\n> = [TSchema] extends [FieldSchema<infer Kind, infer Types>]\n\t? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true>\n\t: [TSchema] extends [ImplicitAllowedTypes]\n\t\t? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>\n\t\t: never;\n\n/**\n * Content which could be inserted into a field within a tree.\n *\n * @see {@link Input}\n * @remarks\n * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.\n * @alpha\n */\nexport type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [\n\tTSchema,\n] extends [ImplicitFieldSchema]\n\t? InsertableTreeFieldFromImplicitField<TSchema>\n\t: [TSchema] extends [UnsafeUnknownSchema]\n\t\t? InsertableContent | undefined\n\t\t: never;\n\n/**\n * Content which could be read from a field within a tree.\n *\n * @remarks\n * Extended version of {@link TreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.\n * Since reading from fields with non-exact schema is still safe, this is only useful (compared to {@link TreeFieldFromImplicitField}) when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}\n * for use\n * @system @alpha\n */\nexport type ReadableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> =\n\tTreeFieldFromImplicitField<ReadSchema<TSchema>>;\n\n/**\n * Adapter to remove {@link (UnsafeUnknownSchema:type)} from a schema type so it can be used with types for generating APIs for reading data.\n *\n * @remarks\n * Since reading with non-exact schema is still safe, this is mainly useful when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}.\n * @system @alpha\n */\nexport type ReadSchema<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [\n\tTSchema,\n] extends [ImplicitFieldSchema]\n\t? TSchema\n\t: ImplicitFieldSchema;\n\n/**\n * Suitable for output.\n * For input must error on side of excluding undefined instead.\n * @system @public\n */\nexport type ApplyKind<T, Kind extends FieldKind> = {\n\t[FieldKind.Required]: T;\n\t[FieldKind.Optional]: T | undefined;\n\t[FieldKind.Identifier]: T;\n}[Kind];\n\n/**\n * Suitable for input.\n *\n * @see {@link Input}\n * @system @public\n */\nexport type ApplyKindInput<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = [\n\tKind,\n] extends [FieldKind.Required]\n\t? T\n\t: [Kind] extends [FieldKind.Optional]\n\t\t? T | undefined\n\t\t: [Kind] extends [FieldKind.Identifier]\n\t\t\t? DefaultsAreOptional extends true\n\t\t\t\t? T | undefined\n\t\t\t\t: T\n\t\t\t: never;\n"]}
+{"version":3,"file":"fieldSchema.js","sourceRoot":"","sources":["../../src/simple-tree/fieldSchema.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 { ErasedType } from \"@fluidframework/core-interfaces\";\nimport { Lazy } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport type { FieldKey } from \"../core/index.js\";\nimport type { FlexTreeHydratedContextMinimal } from \"../feature-libraries/index.js\";\nimport {\n\ttype MakeNominal,\n\tbrand,\n\ttype UnionToIntersection,\n\tcompareSets,\n\ttype requireTrue,\n\ttype areOnlyKeys,\n\ttype JsonCompatibleReadOnlyObject,\n} from \"../util/index.js\";\n\nimport type {\n\tTreeNodeSchema,\n\tTreeNode,\n\tUnhydratedFlexTreeNode,\n\tImplicitAllowedTypes,\n\tTreeNodeFromImplicitAllowedTypes,\n\tTreeLeafValue,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tAllowedTypesFull,\n\tSchemaUpgrade,\n} from \"./core/index.js\";\nimport { AnnotatedAllowedTypesInternal, normalizeAllowedTypes } from \"./core/index.js\";\nimport type {\n\tSchemaType,\n\tSimpleAllowedTypeAttributes,\n\tSimpleFieldSchema,\n} from \"./simpleSchema.js\";\nimport type { InsertableContent } from \"./unhydratedFlexTreeFromInsertable.js\";\nimport type { UnsafeUnknownSchema } from \"./unsafeUnknownSchema.js\";\n\n/**\n * Kind of a field on an {@link TreeObjectNode}.\n * @remarks\n * More kinds may be added over time, so do not assume this is an exhaustive set.\n * See {@link FieldSchema} for where these are used, and {@link SchemaFactory} for how to create schema which use them.\n * @public\n */\nexport enum FieldKind {\n\t/**\n\t * A field which can be empty or filled.\n\t * @remarks\n\t * Allows 0 or one child.\n\t */\n\tOptional,\n\t/**\n\t * A field which must always be filled.\n\t * @remarks\n\t * Only allows exactly one child.\n\t */\n\tRequired,\n\t/**\n\t * A special readonly field used for node identifier strings.\n\t * @remarks\n\t * Only allows exactly one child.\n\t *\n\t * See {@link SchemaFactory.identifier} for more details.\n\t */\n\tIdentifier,\n}\n\n/**\n * Maps from a property key to its corresponding {@link FieldProps.key | stored key} for the provided\n * {@link ImplicitFieldSchema | field schema}.\n *\n * @remarks\n * If an explicit stored key was specified in the schema, it will be used.\n * Otherwise, the stored key is the same as the property key.\n */\nexport function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {\n\treturn brand(getExplicitStoredKey(fieldSchema) ?? propertyKey);\n}\n\n/**\n * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.\n * Otherwise, returns undefined.\n */\nexport function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {\n\treturn fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;\n}\n\n/**\n * Additional information to provide to a {@link FieldSchema}.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @public\n */\nexport interface FieldProps<TCustomMetadata = unknown> {\n\t/**\n\t * The unique identifier of a field, used in the persisted form of the tree.\n\t *\n\t * @remarks\n\t * If not explicitly set via the schema, this is the same as the schema's property key.\n\t *\n\t * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.\n\t * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,\n\t * you can change the property key and specify the previous property key as the stored key.\n\t *\n\t * Notes:\n\t *\n\t * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`\n\t * will always return the property keys specified in the schema, ignoring any stored keys that differ from\n\t * the property keys.\n\t *\n\t * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys\n\t * (accounting for those implicitly derived from property keys) contains no duplicates.\n\t * This is validated at runtime.\n\t *\n\t * @example Refactoring code without breaking compatibility with existing data\n\t *\n\t * Consider some existing object schema:\n\t *\n\t * ```TypeScript\n\t * class Point extends schemaFactory.object(\"Point\", {\n\t * \txPosition: schemaFactory.number,\n\t * \tyPosition: schemaFactory.number,\n\t * \tzPosition: schemaFactory.optional(schemaFactory.number),\n\t * });\n\t * ```\n\t *\n\t * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.\n\t *\n\t * We would like to refactor the schema to omit \"Position\" from the property keys, but application data has\n\t * already been persisted using the original property keys. To maintain compatibility with existing data,\n\t * we can refactor the schema as follows:\n\t *\n\t * ```TypeScript\n\t * class Point extends schemaFactory.object(\"Point\", {\n\t * \tx: schemaFactory.required(schemaFactory.number, { key: \"xPosition\" }),\n\t * \ty: schemaFactory.required(schemaFactory.number, { key: \"yPosition\" }),\n\t * \tz: schemaFactory.optional(schemaFactory.number, { key: \"zPosition\" }),\n\t * });\n\t * ```\n\t *\n\t * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.\n\t *\n\t * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.\n\t */\n\treadonly key?: string;\n\n\t/**\n\t * A default provider used for fields which were not provided any values.\n\t * @privateRemarks\n\t * We are using an erased type here, as we want to expose this API but `InsertableContent` and `NodeKeyManager` are not public.\n\t */\n\treadonly defaultProvider?: DefaultProvider;\n\n\t/**\n\t * Optional metadata to associate with the field.\n\t *\n\t * @remarks\n\t * Note: this metadata is not persisted nor made part of the collaborative state; it is strictly client-local.\n\t * Different clients in the same collaborative session may see different metadata for the same field.\n\t */\n\treadonly metadata?: FieldSchemaMetadata<TCustomMetadata>;\n}\n\n/**\n * {@link FieldProps} extended with additional `alpha` options.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @alpha @input\n */\nexport interface FieldPropsAlpha<TCustomMetadata = unknown>\n\textends FieldProps<TCustomMetadata> {\n\t/**\n\t * The persisted metadata for a field schema.\n\t * @remarks\n\t * Sets {@link SimpleFieldSchema.persistedMetadata}.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n\n\t/**\n\t * If defined, indicates that this field is a {@link SchemaStaticsAlpha.stagedOptional | staged optional} field.\n\t */\n\treadonly stagedOptionalUpgrade?: SchemaUpgrade;\n}\n\n/**\n * A {@link FieldProvider} which requires additional context in order to produce its content\n */\nexport type ContextualFieldProvider = (\n\tcontext: FlexTreeHydratedContextMinimal | \"UseGlobalContext\",\n) => UnhydratedFlexTreeNode[];\n/**\n * A {@link FieldProvider} which can produce its content in a vacuum.\n */\nexport type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];\n/**\n * A function which produces content for a field every time that it is called.\n */\nexport type FieldProvider = ContextualFieldProvider | ConstantFieldProvider;\n/**\n * Returns true if the given {@link FieldProvider} is a {@link ConstantFieldProvider}\n */\nexport function isConstant(\n\tfieldProvider: FieldProvider,\n): fieldProvider is ConstantFieldProvider {\n\treturn fieldProvider.length === 0;\n}\n\n/**\n * Provides a default value for a field.\n * @remarks\n * If present in a `FieldSchema`, when constructing new tree content that field can be omitted, and a default will be provided.\n * @system @sealed @public\n */\nexport interface DefaultProvider extends ErasedType<\"@fluidframework/tree.FieldProvider\"> {}\n\nexport function extractFieldProvider(input: DefaultProvider): FieldProvider {\n\treturn input as unknown as FieldProvider;\n}\n\nexport function getDefaultProvider(input: FieldProvider): DefaultProvider {\n\treturn input as unknown as DefaultProvider;\n}\n\n/**\n * Metadata associated with a {@link FieldSchema}.\n *\n * @remarks Specified via {@link FieldProps.metadata}.\n *\n * @sealed\n * @public\n */\nexport interface FieldSchemaMetadata<TCustomMetadata = unknown> {\n\t/**\n\t * User-defined metadata.\n\t */\n\treadonly custom?: TCustomMetadata;\n\n\t/**\n\t * The description of the field.\n\t *\n\t * @remarks\n\t *\n\t * If provided, will be used by the system in scenarios where a description of the field is useful.\n\t * E.g., when converting a field schema to {@link https://json-schema.org/ | JSON Schema}, this description will be\n\t * used as the `description` field.\n\t */\n\treadonly description?: string | undefined;\n}\n\n/**\n * Metadata associated with a {@link FieldSchema}. Includes fields used by alpha features.\n *\n * @remarks Specified via {@link FieldProps.metadata}.\n *\n * @sealed\n * @alpha\n */\nexport interface FieldSchemaMetadataAlpha<TCustomMetadata = unknown>\n\textends FieldSchemaMetadata<TCustomMetadata> {\n\t/**\n\t * The persisted metadata for this schema element.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n}\n\n/**\n * Package internal construction API.\n */\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n>(kind: Kind, annotatedTypes: Types): FieldSchemaAlpha<Kind, Types, TCustomMetadata>;\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n\tTProps extends FieldProps<TCustomMetadata> = FieldProps<TCustomMetadata>,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops: TProps,\n): FieldSchemaAlpha<Kind, Types, TCustomMetadata, TProps>;\nexport function createFieldSchema<\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata = unknown,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n): FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined> {\n\treturn createFieldSchemaPrivate(kind, annotatedTypes, props);\n}\n\n/**\n * Implementation for {@link createFieldSchema}\n */\nlet createFieldSchemaPrivate: <\n\tKind extends FieldKind,\n\tTypes extends ImplicitAllowedTypes,\n\tTCustomMetadata,\n>(\n\tkind: Kind,\n\tannotatedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n) => FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined>;\n\n/**\n * All policy for a specific field,\n * including functionality that does not have to be kept consistent across versions or deterministic.\n *\n * This can include policy for how to use this schema for \"view\" purposes, and well as how to expose editing APIs.\n * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link SchemaStatics.optional}.\n * @privateRemarks\n * Public access to the constructor is removed to prevent creating expressible but unsupported (or not stable) configurations.\n * {@link createFieldSchema} can be used internally to create instances.\n *\n * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n * See {@link FieldSchemaMetadata.custom}.\n *\n * @remarks\n * All implementations of this are actually {@link FieldSchemaAlpha} which exposes some additional alpha APIs.\n *\n * @sealed @public\n */\nexport class FieldSchema<\n\tout Kind extends FieldKind = FieldKind,\n\tout Types extends ImplicitAllowedTypes = ImplicitAllowedTypes,\n\tout TCustomMetadata = unknown,\n> {\n\t/**\n\t * This class is used with instanceof, and therefore should have nominal typing.\n\t * This field enforces that.\n\t */\n\tprotected _typeCheck!: MakeNominal;\n\n\tprivate readonly lazyTypes: Lazy<ReadonlySet<TreeNodeSchema>>;\n\n\t/**\n\t * What types of tree nodes are allowed in this field.\n\t * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.\n\t */\n\tpublic get allowedTypeSet(): ReadonlySet<TreeNodeSchema> {\n\t\treturn this.lazyTypes.value;\n\t}\n\n\t/**\n\t * True if and only if, when constructing a node with this field, a value must be provided for it.\n\t */\n\tpublic readonly requiresValue: boolean;\n\n\t/**\n\t * {@inheritDoc FieldProps.metadata}\n\t */\n\tpublic get metadata(): FieldSchemaMetadata<TCustomMetadata> {\n\t\treturn this.props?.metadata ?? {};\n\t}\n\n\t/**\n\t * This class is `@sealed`: protected members like this constructor are for internal use only.\n\t * Use {@link SchemaFactory} to create the FieldSchema instances.\n\t */\n\tprotected constructor(\n\t\t/**\n\t\t * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.\n\t\t * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.\n\t\t */\n\t\tpublic readonly kind: Kind,\n\t\t/**\n\t\t * What types of tree nodes are allowed in this field.\n\t\t */\n\t\tpublic readonly allowedTypes: Types,\n\t\t/**\n\t\t * Optional properties associated with the field.\n\t\t */\n\t\tpublic readonly props?: FieldProps<TCustomMetadata>,\n\t) {\n\t\tif (!(this instanceof FieldSchemaAlpha)) {\n\t\t\tthrow new UsageError(\"FieldSchema is @sealed: sub-classing is not allowed.\");\n\t\t}\n\n\t\tthis.lazyTypes = new Lazy(() => normalizeAllowedTypes(this.allowedTypes).evaluateSet());\n\t\t// TODO: optional fields should (by default) get a default provider that returns undefined, removing the need to special case them here:\n\t\tthis.requiresValue =\n\t\t\tthis.props?.defaultProvider === undefined && this.kind !== FieldKind.Optional;\n\t}\n}\n\n/**\n * {@link FieldSchema} including alpha APIs (currently {@link SimpleFieldSchema}).\n * @remarks\n * This class will go away once the alpha APIs are stable and implemented by {@link FieldSchema}.\n * @sealed @alpha\n */\nexport class FieldSchemaAlpha<\n\t\tKind extends FieldKind = FieldKind,\n\t\tTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes,\n\t\tTCustomMetadata = unknown,\n\t\tTProps extends FieldPropsAlpha<TCustomMetadata> | undefined =\n\t\t\t| FieldPropsAlpha<TCustomMetadata>\n\t\t\t| undefined,\n\t>\n\textends FieldSchema<Kind, Types, TCustomMetadata>\n\timplements SimpleFieldSchema<SchemaType.View>\n{\n\tprivate readonly propsAlpha: TProps;\n\n\tpublic get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined {\n\t\treturn this.propsAlpha?.persistedMetadata;\n\t}\n\n\tpublic get isStagedOptional(): false | SchemaUpgrade {\n\t\treturn this.propsAlpha?.stagedOptionalUpgrade ?? false;\n\t}\n\n\tstatic {\n\t\tcreateFieldSchemaPrivate = <\n\t\t\tKind2 extends FieldKind,\n\t\t\tTypes2 extends ImplicitAllowedTypes,\n\t\t\tTCustomMetadata2,\n\t\t>(\n\t\t\tkind: Kind2,\n\t\t\tannotatedAllowedTypes: Types2,\n\t\t\tprops?: FieldPropsAlpha<TCustomMetadata2>,\n\t\t) =>\n\t\t\t// TCustomMetadata2 requires type assertion due to limitations with dependent type parameters\n\t\t\tnew FieldSchemaAlpha(kind, annotatedAllowedTypes, props) as unknown as FieldSchemaAlpha<\n\t\t\t\tKind2,\n\t\t\t\tTypes2,\n\t\t\t\tTCustomMetadata2\n\t\t\t>;\n\t}\n\n\t/**\n\t * {@link normalizeAllowedTypes|Normalized} version of {@link FieldSchema.allowedTypes}.\n\t */\n\tpublic readonly allowedTypesFull: AllowedTypesFull;\n\n\tpublic get allowedTypesIdentifiers(): ReadonlySet<string> {\n\t\treturn this.allowedTypesFull.evaluateIdentifiers();\n\t}\n\n\tpublic get simpleAllowedTypes(): ReadonlyMap<\n\t\tstring,\n\t\tSimpleAllowedTypeAttributes<SchemaType.View>\n\t> {\n\t\treturn AnnotatedAllowedTypesInternal.evaluateSimpleAllowedTypes(this.allowedTypesFull);\n\t}\n\n\tprotected constructor(\n\t\tkind: Kind,\n\t\ttypes: Types,\n\n\t\tprops?: FieldPropsAlpha<TCustomMetadata>,\n\t) {\n\t\tsuper(kind, types, props);\n\n\t\tconst normalizedTypes = normalizeAllowedTypes(types);\n\t\tthis.allowedTypesFull = normalizedTypes;\n\t\tthis.propsAlpha = props as TProps;\n\t}\n}\n\n/**\n * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitFieldSchema} to a {@link FieldSchema}.\n * @internal\n */\nexport function normalizeFieldSchema(\n\tschema: ImplicitFieldSchema | ImplicitFieldSchema,\n): FieldSchemaAlpha {\n\treturn schema instanceof FieldSchema\n\t\t? (schema as FieldSchemaAlpha)\n\t\t: createFieldSchema(FieldKind.Required, schema);\n}\n\n/**\n * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.\n * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:\n * 1. They have the same {@link FieldKind | kinds}.\n * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.\n * 3. They have the same exact set of allowed types. The allowed types must be (respectively) reference equal.\n *\n * For example, comparing an ImplicitFieldSchema that is a {@link TreeNodeSchema} to an ImplicitFieldSchema that is a {@link FieldSchema}\n * will return true if they are the same kind, the FieldSchema has exactly one allowed type (the TreeNodeSchema), and they have equivalent FieldProps.\n */\nexport function areImplicitFieldSchemaEqual(\n\ta: ImplicitFieldSchema,\n\tb: ImplicitFieldSchema,\n): boolean {\n\treturn areFieldSchemaEqual(normalizeFieldSchema(a), normalizeFieldSchema(b));\n}\n\n/**\n * Returns true if the given {@link FieldSchema} are equivalent, otherwise false.\n * @remarks Two FieldSchema are considered equivalent if all of the following are true:\n * 1. They have the same {@link FieldKind | kinds}.\n * 2. They have {@link areFieldPropsEqual | equivalent FieldProps}.\n * 3. They have the same exact set of allowed types. The allowed types must be reference equal.\n */\nexport function areFieldSchemaEqual(a: FieldSchema, b: FieldSchema): boolean {\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\tif (a.kind !== b.kind) {\n\t\treturn false;\n\t}\n\n\tif (!areFieldPropsEqual(a.props, b.props)) {\n\t\treturn false;\n\t}\n\n\treturn compareSets({ a: a.allowedTypeSet, b: b.allowedTypeSet });\n}\n\n/**\n * Returns true if the given {@link FieldProps} are equivalent, otherwise false.\n * @remarks FieldProps are considered equivalent if their keys and default providers are reference equal, and their metadata are {@link areMetadataEqual | equivalent}.\n */\nfunction areFieldPropsEqual(a: FieldProps | undefined, b: FieldProps | undefined): boolean {\n\t// If any new fields are added to FieldProps, this check will stop compiling as a reminder that this function needs to be updated.\n\ttype _keys = requireTrue<areOnlyKeys<FieldProps, \"key\" | \"defaultProvider\" | \"metadata\">>;\n\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\tif (a?.key !== b?.key || a?.defaultProvider !== b?.defaultProvider) {\n\t\treturn false;\n\t}\n\n\tif (!areMetadataEqual(a?.metadata, b?.metadata)) {\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n/**\n * Returns true if the given {@link FieldSchemaMetadata} are equivalent, otherwise false.\n * @remarks FieldSchemaMetadata are considered equivalent if their custom data and descriptions are (respectively) reference equal.\n */\nfunction areMetadataEqual(\n\ta: FieldSchemaMetadataAlpha | undefined,\n\tb: FieldSchemaMetadataAlpha | undefined,\n): boolean {\n\t// If any new fields are added to FieldSchemaMetadata, this check will stop compiling as a reminder that this function needs to be updated.\n\ttype _keys = requireTrue<\n\t\tareOnlyKeys<FieldSchemaMetadataAlpha, \"custom\" | \"description\" | \"persistedMetadata\">\n\t>;\n\n\tif (a === b) {\n\t\treturn true;\n\t}\n\n\treturn (\n\t\tObject.is(a?.custom, b?.custom) &&\n\t\ta?.description === b?.description &&\n\t\tarePersistedMetadataEqual(a?.persistedMetadata, b?.persistedMetadata)\n\t);\n}\n\n/**\n * Returns true if the given persisted metadata fields are equivalent, otherwise false.\n * @remarks\n * Currently only handles shallow equality in the case where the keys are in the same order. This is acceptable for current use cases.\n */\nfunction arePersistedMetadataEqual(\n\ta: JsonCompatibleReadOnlyObject | undefined,\n\tb: JsonCompatibleReadOnlyObject | undefined,\n): boolean {\n\tif (Object.is(a, b)) {\n\t\treturn true;\n\t}\n\n\tif (a === undefined || b === undefined) {\n\t\treturn false;\n\t}\n\n\t// Note that the key order matters. If `a` and `b` have the same content but the keys are in a different order,\n\t// this method will return false.\n\tconst aStringified = JSON.stringify(a);\n\tconst bStringified = JSON.stringify(b);\n\n\treturn aStringified === bStringified;\n}\n\n/**\n * Schema for a field of a tree node.\n * @remarks\n * Implicitly treats {@link ImplicitAllowedTypes} as a Required field of that type.\n * @public\n */\nexport type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;\n\n/**\n * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.\n *\n * @typeparam TSchema - When non-exact schema are provided this errors on the side of returning too general of a type (a conservative union of all possibilities).\n * This is ideal for \"output APIs\" - i.e. it converts the schema type to the runtime type that a user will _read_ from the tree.\n * Examples of such \"non-exact\" schema include `ImplicitFieldSchema`, `ImplicitAllowedTypes`, and  TypeScript unions of schema types.\n * @public\n */\nexport type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> =\n\tTSchema extends FieldSchema<infer Kind, infer Types>\n\t\t? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind>\n\t\t: TSchema extends ImplicitAllowedTypes\n\t\t\t? TreeNodeFromImplicitAllowedTypes<TSchema>\n\t\t\t: TreeNode | TreeLeafValue | undefined;\n\n/**\n * Type of content that can be inserted into the tree for a field of the given schema.\n *\n * @see {@link Input}\n *\n * @typeparam TSchemaInput - Schema to process.\n * @typeparam TSchema - Do not specify: default value used as implementation detail.\n * @public\n */\nexport type InsertableTreeFieldFromImplicitField<\n\tTSchemaInput extends ImplicitFieldSchema,\n\tTSchema = UnionToIntersection<TSchemaInput>,\n> = [TSchema] extends [FieldSchema<infer Kind, infer Types>]\n\t? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true>\n\t: [TSchema] extends [ImplicitAllowedTypes]\n\t\t? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>\n\t\t: never;\n\n/**\n * Content which could be inserted into a field within a tree.\n *\n * @see {@link Input}\n * @remarks\n * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.\n * @alpha\n */\nexport type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [\n\tTSchema,\n] extends [ImplicitFieldSchema]\n\t? InsertableTreeFieldFromImplicitField<TSchema>\n\t: [TSchema] extends [UnsafeUnknownSchema]\n\t\t? InsertableContent | undefined\n\t\t: never;\n\n/**\n * Content which could be read from a field within a tree.\n *\n * @remarks\n * Extended version of {@link TreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.\n * Since reading from fields with non-exact schema is still safe, this is only useful (compared to {@link TreeFieldFromImplicitField}) when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}\n * for use\n * @system @alpha\n */\nexport type ReadableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> =\n\tTreeFieldFromImplicitField<ReadSchema<TSchema>>;\n\n/**\n * Adapter to remove {@link (UnsafeUnknownSchema:type)} from a schema type so it can be used with types for generating APIs for reading data.\n *\n * @remarks\n * Since reading with non-exact schema is still safe, this is mainly useful when the schema is also used as input and thus allows {@link (UnsafeUnknownSchema:type)}.\n * @system @alpha\n */\nexport type ReadSchema<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [\n\tTSchema,\n] extends [ImplicitFieldSchema]\n\t? TSchema\n\t: ImplicitFieldSchema;\n\n/**\n * Suitable for output.\n * For input must error on side of excluding undefined instead.\n * @system @public\n */\nexport type ApplyKind<T, Kind extends FieldKind> = {\n\t[FieldKind.Required]: T;\n\t[FieldKind.Optional]: T | undefined;\n\t[FieldKind.Identifier]: T;\n}[Kind];\n\n/**\n * Suitable for input.\n *\n * @see {@link Input}\n * @system @public\n */\nexport type ApplyKindInput<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = [\n\tKind,\n] extends [FieldKind.Required]\n\t? T\n\t: [Kind] extends [FieldKind.Optional]\n\t\t? T | undefined\n\t\t: [Kind] extends [FieldKind.Identifier]\n\t\t\t? DefaultsAreOptional extends true\n\t\t\t\t? T | undefined\n\t\t\t\t: T\n\t\t\t: never;\n"]}

package/dist/simple-tree/getTreeNodeForField.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryGetTreeNodeForField = void 0;
+exports.tryGetTreeNodeForField = tryGetTreeNodeForField;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../feature-libraries/index.js");
 const index_js_2 = require("./core/index.js");
@@ -36,5 +36,4 @@ function tryGetTreeNodeForField(field) {
         }
     }
 }
-exports.tryGetTreeNodeForField = tryGetTreeNodeForField;
 //# sourceMappingURL=getTreeNodeForField.js.map

package/dist/simple-tree/getTreeNodeForField.js.map

@@ -1 +1 @@
-{"version":3,"file":"getTreeNodeForField.js","sourceRoot":"","sources":["../../src/simple-tree/getTreeNodeForField.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA2D;AAG3D,4DAMuC;AAEvC,8CAA8E;AAE9E;;GAEG;AACH,SAAgB,sBAAsB,CACrC,KAAoB;IAEpB,SAAS,gBAAgB,CACxB,SAAwD;QAExD,MAAM,YAAY,GAAG,SAAS,CAAC,OAAO,CAAC;QACvC,OAAO,IAAA,yBAAc,EAAC,YAAY,CAAC;YAClC,CAAC,CAAC,IAAA,uCAA4B,EAAC,YAAY,CAAC;YAC5C,CAAC,CAAC,YAAY,CAAC;IACjB,CAAC;IACD,QAAQ,KAAK,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,qBAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,KAA8B,CAAC;YAClD,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,qBAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,KAA8B,CAAC;YAClD,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,qBAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;YACvC,+DAA+D;YAC/D,OAAQ,KAA+B,CAAC,OAAiB,CAAC;QAC3D,CAAC;QAED,OAAO,CAAC,CAAC,CAAC;YACT,IAAA,eAAI,EAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACtC,CAAC;IACF,CAAC;AACF,CAAC;AA7BD,wDA6BC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { fail } from \"@fluidframework/core-utils/internal\";\n\nimport type { TreeValue } from \"../core/index.js\";\nimport {\n\tFieldKinds,\n\ttype FlexTreeField,\n\tisFlexTreeNode,\n\ttype FlexTreeRequiredField,\n\ttype FlexTreeOptionalField,\n} from \"../feature-libraries/index.js\";\n\nimport { type TreeNode, getOrCreateNodeFromInnerNode } from \"./core/index.js\";\n\n/**\n * Retrieve the associated {@link TreeNode} for the given field's content.\n */\nexport function tryGetTreeNodeForField(\n\tfield: FlexTreeField,\n): TreeNode | TreeValue | undefined {\n\tfunction tryToUnboxLeaves(\n\t\tflexField: FlexTreeOptionalField | FlexTreeRequiredField,\n\t): TreeNode | TreeValue | undefined {\n\t\tconst maybeContent = flexField.content;\n\t\treturn isFlexTreeNode(maybeContent)\n\t\t\t? getOrCreateNodeFromInnerNode(maybeContent)\n\t\t\t: maybeContent;\n\t}\n\tswitch (field.schema) {\n\t\tcase FieldKinds.required.identifier: {\n\t\t\tconst typedField = field as FlexTreeRequiredField;\n\t\t\treturn tryToUnboxLeaves(typedField);\n\t\t}\n\t\tcase FieldKinds.optional.identifier: {\n\t\t\tconst typedField = field as FlexTreeOptionalField;\n\t\t\treturn tryToUnboxLeaves(typedField);\n\t\t}\n\t\tcase FieldKinds.identifier.identifier: {\n\t\t\t// Identifier fields are just required fields that hold strings\n\t\t\treturn (field as FlexTreeRequiredField).content as string;\n\t\t}\n\n\t\tdefault: {\n\t\t\tfail(0xadf /* invalid field kind */);\n\t\t}\n\t}\n}\n"]}
+{"version":3,"file":"getTreeNodeForField.js","sourceRoot":"","sources":["../../src/simple-tree/getTreeNodeForField.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAkBH,wDA6BC;AA7CD,kEAA2D;AAG3D,4DAMuC;AAEvC,8CAA8E;AAE9E;;GAEG;AACH,SAAgB,sBAAsB,CACrC,KAAoB;IAEpB,SAAS,gBAAgB,CACxB,SAAwD;QAExD,MAAM,YAAY,GAAG,SAAS,CAAC,OAAO,CAAC;QACvC,OAAO,IAAA,yBAAc,EAAC,YAAY,CAAC;YAClC,CAAC,CAAC,IAAA,uCAA4B,EAAC,YAAY,CAAC;YAC5C,CAAC,CAAC,YAAY,CAAC;IACjB,CAAC;IACD,QAAQ,KAAK,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,qBAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,KAA8B,CAAC;YAClD,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,qBAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,KAA8B,CAAC;YAClD,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,qBAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;YACvC,+DAA+D;YAC/D,OAAQ,KAA+B,CAAC,OAAiB,CAAC;QAC3D,CAAC;QAED,OAAO,CAAC,CAAC,CAAC;YACT,IAAA,eAAI,EAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACtC,CAAC;IACF,CAAC;AACF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { fail } from \"@fluidframework/core-utils/internal\";\n\nimport type { TreeValue } from \"../core/index.js\";\nimport {\n\tFieldKinds,\n\ttype FlexTreeField,\n\tisFlexTreeNode,\n\ttype FlexTreeRequiredField,\n\ttype FlexTreeOptionalField,\n} from \"../feature-libraries/index.js\";\n\nimport { type TreeNode, getOrCreateNodeFromInnerNode } from \"./core/index.js\";\n\n/**\n * Retrieve the associated {@link TreeNode} for the given field's content.\n */\nexport function tryGetTreeNodeForField(\n\tfield: FlexTreeField,\n): TreeNode | TreeValue | undefined {\n\tfunction tryToUnboxLeaves(\n\t\tflexField: FlexTreeOptionalField | FlexTreeRequiredField,\n\t): TreeNode | TreeValue | undefined {\n\t\tconst maybeContent = flexField.content;\n\t\treturn isFlexTreeNode(maybeContent)\n\t\t\t? getOrCreateNodeFromInnerNode(maybeContent)\n\t\t\t: maybeContent;\n\t}\n\tswitch (field.schema) {\n\t\tcase FieldKinds.required.identifier: {\n\t\t\tconst typedField = field as FlexTreeRequiredField;\n\t\t\treturn tryToUnboxLeaves(typedField);\n\t\t}\n\t\tcase FieldKinds.optional.identifier: {\n\t\t\tconst typedField = field as FlexTreeOptionalField;\n\t\t\treturn tryToUnboxLeaves(typedField);\n\t\t}\n\t\tcase FieldKinds.identifier.identifier: {\n\t\t\t// Identifier fields are just required fields that hold strings\n\t\t\treturn (field as FlexTreeRequiredField).content as string;\n\t\t}\n\n\t\tdefault: {\n\t\t\tfail(0xadf /* invalid field kind */);\n\t\t}\n\t}\n}\n"]}

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

@@ -2,10 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-export { typeNameSymbol, typeSchemaSymbol, contentSchemaSymbol, type WithType, type TreeNodeSchema, type AnnotatedAllowedType, type AllowedTypesFullEvaluated, NodeKind, type TreeNodeSchemaClass, type TreeNodeSchemaNonClass, type TreeNodeSchemaCore, TreeNode, type Unhydrated, type InternalTreeNode, isTreeNode, tryDisposeTreeNode, HydratedContext, SimpleContextSlot, getInnerNode, getOrCreateNodeFromInnerNode, getOrCreateNodeFromInnerUnboxedNode, getKernel, type NodeFromSchema, isTreeNodeSchemaClass, type TreeNodeFromImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type TreeLeafValue, type AllowedTypes, type InsertableTreeNodeFromAllowedTypes, type InsertableTypedNode, type NodeBuilderData, type Input, normalizeAllowedTypes, type NodeSchemaMetadata, type ImplicitAllowedTypes, type AllowedTypesMetadata, evaluateLazySchema, type UnannotateAllowedTypesList, type AllowedTypeMetadata, type AnnotatedAllowedTypes, SchemaUpgrade, type LazyItem, type FlexList, type FlexListToUnion, type ExtractItemType, walkNodeSchema, walkAllowedTypes, type SchemaVisitor, type SimpleNodeSchemaBase, withBufferedTreeEvents, type AnnotateAllowedTypesList, type AllowedTypesFull, type AllowedTypesFullFromMixed, AnnotatedAllowedTypesInternal, type NumberKeys, StagedSchemaUpgradePolicy, type StagedSchemaUpgradePolicyFactory, ExpectStored, createSchemaUpgrade, } from "./core/index.js";
+export { schemaIdentifierBrand, typeSchemaSymbol, contentSchemaSymbol, type WithType, type TreeNodeSchema, type AnnotatedAllowedType, type AllowedTypesFullEvaluated, NodeKind, type TreeNodeSchemaClass, type TreeNodeSchemaNonClass, type TreeNodeSchemaCore, TreeNode, type Unhydrated, type InternalTreeNode, isTreeNode, tryDisposeTreeNode, HydratedContext, SimpleContextSlot, getInnerNode, getOrCreateNodeFromInnerNode, getOrCreateNodeFromInnerUnboxedNode, getKernel, type NodeFromSchema, isTreeNodeSchemaClass, type TreeNodeFromImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type TreeLeafValue, type AllowedTypes, type InsertableTreeNodeFromAllowedTypes, type InsertableTypedNode, type NodeBuilderData, type Input, normalizeAllowedTypes, type NodeSchemaMetadata, type ImplicitAllowedTypes, type AllowedTypesMetadata, evaluateLazySchema, type UnannotateAllowedTypesList, type AllowedTypeMetadata, type AnnotatedAllowedTypes, SchemaUpgrade, type LazyItem, type FlexList, type FlexListToUnion, type ExtractItemType, walkNodeSchema, walkAllowedTypes, type SchemaVisitor, type SimpleNodeSchemaBase, withBufferedTreeEvents, type AnnotateAllowedTypesList, type AllowedTypesFull, type AllowedTypesFullFromMixed, AnnotatedAllowedTypesInternal, type NumberKeys, StagedSchemaUpgradePolicy, type StagedSchemaUpgradePolicyFactory, ExpectStored, createSchemaUpgrade, } from "./core/index.js";
 export { walkFieldSchema } from "./walkFieldSchema.js";
 export type { UnsafeUnknownSchema, Insertable } from "./unsafeUnknownSchema.js";
-export { type CommitRevision, type ITree, type TreeView, type ViewableTree, type TreeViewEvents, TreeViewConfiguration, TreeViewConfigurationAlpha, type ITreeViewConfiguration, type ITreeViewConfigurationAlpha, type SchemaCompatibilityStatus, type SchemaCompatibilityStatusBeta, type SchemaDiscrepancy, type ITreeConfigurationOptions, SchemaFactory, scoped, SchemaFactoryBeta, type SchemaStaticsBeta, SchemaFactoryAlpha, type SchemaStaticsAlpha, type NodeProvider, type ObjectSchemaOptionsAlpha, type ObjectSchemaOptions, type ScopedSchemaName, type ValidateRecursiveSchema, type FixRecursiveArraySchema, adaptEnum, enumFromStrings, singletonSchema, treeNodeApi, type TreeNodeApi, type ArrayNodeDeltaOp, type ArrayNodeInsertOp, type ArrayNodeRemoveOp, type ArrayNodeRetainOp, type ArrayNodeTreeChangedDeltaOp, type ArrayNodeTreeChangedRetainOp, type NodeChangedData, type NodeChangedDataAlpha, type NodeChangedDataDelta, type NodeChangedDataProperties, type NodeChangedDataTreeDelta, borrowCursorFromTreeNodeOrValue, exportConcise, importConcise, TreeBeta, type TreeChangeEventsBeta, type TreeChangeEventsAlpha, type IdentifierIndex, createTreeIndex, createIdentifierIndex, type TreeIndexKey, type DirtyTreeStatus, trackDirtyNodes, type DirtyTreeMap, type JsonSchemaId, type JsonSchemaType, type JsonObjectNodeSchema, type JsonArrayNodeSchema, type JsonMapNodeSchema, type JsonLeafNodeSchema, type JsonSchemaRef, type JsonRefPath, type JsonNodeSchema, type JsonNodeSchemaBase, type JsonTreeSchema, type JsonFieldSchema, type JsonLeafSchemaType, type JsonRecordNodeSchema, type JsonStringKeyPatternProperties, type TreeSchemaEncodingOptions, getJsonSchema, getSimpleSchema, type StagedUpgradeStatus, type VerboseTreeNode, type TreeEncodingOptions, type VerboseTree, extractPersistedSchema, comparePersistedSchema, type ConciseTree, checkSchemaCompatibility, getSchemaIncompatibilityDetails, type Unenforced, type System_Unsafe, type ArrayNodeCustomizableSchemaUnsafe, type MapNodeCustomizableSchemaUnsafe, type TreeRecordNodeUnsafe, type UnannotateAllowedTypeUnsafe, type AnnotatedAllowedTypeUnsafe, type AnnotatedAllowedTypesUnsafe, type AllowedTypesFullUnsafe, type AllowedTypesFullFromMixedUnsafe, type UnannotateAllowedTypesListUnsafe, type AnnotateAllowedTypesListUnsafe, type FieldHasDefaultAlphaUnsafe, type InsertableObjectFromSchemaRecordAlphaUnsafe, type TreeViewAlpha, type TreeViewBeta, type UntypedTreeView, type TreeBranch, type TreeBranchAlpha, type UntypedTreeViewAlpha, type TreeBranchEvents, type TreeBranchCommitMetadata, type TreeBranchHistory, getPropertyKeyFromStoredKey, getStoredKey, tryGetSchema, applySchemaToParserOptions, cursorFromVerbose, verboseFromCursor, conciseFromCursor, createFromCursor, asTreeViewAlpha, customFromCursorStored, type CustomTreeNode, type CustomTreeValue, tryStoredSchemaAsArray, type SchemaStatics, type ITreeAlpha, type NoChangeConstraint, type NodeInDocumentConstraint, type RunTransactionParamsAlpha, type RunTransactionParamsBeta, type TransactionCallbackStatusAlpha, type TransactionCallbackStatusBeta, type TransactionConstraint, type TransactionConstraintAlpha, type TransactionPostProcessor, type TransactionResultFailed, type TransactionResultSuccess, type TransactionValueResult, type TransactionVoidResult, type VoidTransactionCallbackStatusAlpha, type VoidTransactionCallbackStatusBeta, rollback, generateSchemaFromSimpleSchema, replaceConciseTreeHandles, replaceHandles, replaceVerboseTreeHandles, type HandleConverter, allowUnused, type FieldSchemaAlphaUnsafe, getIdentifierFromNode, type ValidateRecursiveSchemaTemplate, type FixRecursiveRecursionLimit, schemaStatics, type TreeChangeEvents, type NodeSchemaOptions, type NodeSchemaOptionsAlpha, KeyEncodingOptions, type TreeParsingOptions, incrementalSummaryHint, incrementalEncodingPolicyForAllowedTypes, type SchemaFactory_base, encodeSchemaCompatibilitySnapshot, decodeSchemaCompatibilitySnapshot, exportCompatibilitySchemaSnapshot, importCompatibilitySchemaSnapshot, checkCompatibility, eraseSchemaDetails, eraseSchemaDetailsSubclassable, type ErasedSchema, type ErasedNode, type ErasedSchemaSubclassable, snapshotSchemaCompatibility, type SnapshotFileSystem, type SnapshotSchemaCompatibilityOptions, createCustomizedFluidFrameworkScopedFactory, type TreeContextAlpha, type WithValue, } from "./api/index.js";
+export { type CommitRevision, type ITree, type TreeView, type ViewableTree, type TreeViewEvents, TreeViewConfiguration, TreeViewConfigurationAlpha, type ITreeViewConfiguration, type ITreeViewConfigurationAlpha, type SchemaCompatibilityStatus, type SchemaCompatibilityStatusBeta, type SchemaDiscrepancy, type ITreeConfigurationOptions, SchemaFactory, scoped, SchemaFactoryBeta, type SchemaStaticsBeta, SchemaFactoryAlpha, type SchemaStaticsAlpha, type NodeProvider, type ObjectSchemaOptionsAlpha, type ObjectSchemaOptions, type ScopedSchemaName, type ValidateRecursiveSchema, type FixRecursiveArraySchema, adaptEnum, enumFromStrings, singletonSchema, treeNodeApi, type TreeNodeApi, type ArrayNodeDeltaOp, type ArrayNodeInsertOp, type ArrayNodeRemoveOp, type ArrayNodeRetainOp, type ArrayNodeTreeChangedDeltaOp, type ArrayNodeTreeChangedRetainOp, type NodeChangedData, type NodeChangedDataDelta, type NodeChangedDataProperties, type NodeChangedDataTreeDelta, cloneTree, type TreeChangeEventsBeta, type IdentifierIndex, createTreeIndex, createIdentifierIndex, type TreeIndexKey, type DirtyTreeStatus, trackDirtyNodes, type DirtyTreeMap, type JsonSchemaId, type JsonSchemaType, type JsonObjectNodeSchema, type JsonArrayNodeSchema, type JsonMapNodeSchema, type JsonLeafNodeSchema, type JsonSchemaRef, type JsonRefPath, type JsonNodeSchema, type JsonNodeSchemaBase, type JsonTreeSchema, type JsonFieldSchema, type JsonLeafSchemaType, type JsonRecordNodeSchema, type JsonStringKeyPatternProperties, type TreeSchemaEncodingOptions, getJsonSchema, getSimpleSchema, type StagedUpgradeStatus, type VerboseTreeNode, type TreeEncodingOptions, type VerboseTree, extractPersistedSchema, comparePersistedSchema, type ConciseTree, checkSchemaCompatibility, getSchemaIncompatibilityDetails, type Unenforced, type System_Unsafe, type ArrayNodeCustomizableSchemaUnsafe, type MapNodeCustomizableSchemaUnsafe, type TreeRecordNodeUnsafe, type UnannotateAllowedTypeUnsafe, type AnnotatedAllowedTypeUnsafe, type AnnotatedAllowedTypesUnsafe, type AllowedTypesFullUnsafe, type AllowedTypesFullFromMixedUnsafe, type UnannotateAllowedTypesListUnsafe, type AnnotateAllowedTypesListUnsafe, type FieldHasDefaultAlphaUnsafe, type InsertableObjectFromSchemaRecordAlphaUnsafe, type TreeViewAlpha, type TreeViewBeta, type UntypedTreeView, type TreeBranch, type TreeBranchAlpha, type UntypedTreeViewAlpha, type TreeBranchEvents, type TreeBranchCommitMetadata, type TreeBranchHistory, type TreeContextBeta, getPropertyKeyFromStoredKey, getStoredKey, tryGetSchema, applySchemaToParserOptions, cursorFromVerbose, verboseFromCursor, conciseFromCursor, createFromCursor, asTreeViewAlpha, customFromCursorStored, type CustomTreeNode, type CustomTreeValue, tryStoredSchemaAsArray, type SchemaStatics, type ITreeAlpha, type NoChangeConstraint, type NodeInDocumentConstraint, type RunTransactionParamsAlpha, type RunTransactionParamsBeta, type TransactionCallbackStatusAlpha, type TransactionCallbackStatusBeta, type TransactionConstraint, type TransactionConstraintAlpha, type TransactionPostProcessor, type TransactionResultFailed, type TransactionResultSuccess, type TransactionValueResult, type TransactionVoidResult, type VoidTransactionCallbackStatusAlpha, type VoidTransactionCallbackStatusBeta, rollback, generateSchemaFromSimpleSchema, replaceConciseTreeHandles, replaceHandles, replaceVerboseTreeHandles, type HandleConverter, allowUnused, type FieldSchemaAlphaUnsafe, getIdentifierFromNode, type ValidateRecursiveSchemaTemplate, type FixRecursiveRecursionLimit, schemaStatics, type TreeChangeEvents, type NodeSchemaOptions, type NodeSchemaOptionsAlpha, KeyEncodingOptions, type TreeParsingOptions, incrementalSummaryHint, incrementalEncodingPolicyForAllowedTypes, type SchemaFactory_base, encodeSchemaCompatibilitySnapshot, decodeSchemaCompatibilitySnapshot, exportCompatibilitySchemaSnapshot, importCompatibilitySchemaSnapshot, checkCompatibility, eraseSchemaDetails, eraseSchemaDetailsSubclassable, type ErasedSchema, type ErasedNode, type ErasedSchemaSubclassable, snapshotSchemaCompatibility, type SnapshotFileSystem, type SnapshotSchemaCompatibilityOptions, createCustomizedFluidFrameworkScopedFactory, type TreeContextAlpha, type WithValue, } from "./api/index.js";
 export type { SimpleTreeSchema, SimpleNodeSchema, SimpleFieldSchema, SimpleLeafNodeSchema, SimpleMapNodeSchema, SimpleArrayNodeSchema, SimpleObjectNodeSchema, SimpleNodeSchemaBaseAlpha, SimpleObjectFieldSchema, SimpleRecordNodeSchema, SimpleAllowedTypeAttributes, SchemaType, } from "./simpleSchema.js";
 export { type ImplicitFieldSchema, type TreeFieldFromImplicitField, FieldKind, FieldSchema, FieldSchemaAlpha, type InsertableTreeFieldFromImplicitField, type DefaultProvider, type FieldProps, type FieldPropsAlpha, normalizeFieldSchema, areFieldSchemaEqual, areImplicitFieldSchemaEqual, type ApplyKind, type FieldSchemaMetadata, type InsertableField, type ApplyKindInput, type ReadableField, type ReadSchema, } from "./fieldSchema.js";
 export { tryGetTreeNodeForField } from "./getTreeNodeForField.js";