@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/class-tree/schemaFactoryRecursive.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TreeArrayNode } from "../simple-tree";
+import { ImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, NodeKind, TreeMapNode, TreeNodeSchemaClass } from "./schemaTypes";
+import { SchemaFactory } from "./schemaFactory";
+/**
+ * Extends SchemaFactory with utilities for recursive types.
+ *
+ * @remarks This is separated from SchemaFactory as these APIs are more experimental, and may be stabilized independently.
+ *
+ * @sealed @internal
+ */
+export declare class SchemaFactoryRecursive<TScope extends string, TName extends number | string = string> extends SchemaFactory<TScope, TName> {
+    /**
+     * For unknown reasons, recursive lists work better (compile in more cases)
+     * if their constructor takes in an object with a member containing the iterable,
+     * rather than taking the iterable as a parameter directly.
+     *
+     * This version of `list` leverages this fact, and has a constructor that requires its data be passed in like:
+     * ```typescript
+     * new MyRecursiveList({x: theData});
+     * ```
+     */
+    arrayRecursive<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${string}`, NodeKind.Array, TreeArrayNode<T>, {
+        x: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>;
+    }, false>;
+    /**
+     * For unknown reasons, recursive maps work better (compile in more cases)
+     * if their constructor does not take in the desired type.
+     *
+     * This version of `map` leverages this fact and takes in undefined instead.
+     * Unfortunately this means all maps created this way must be created empty then filled later.
+     * @privateRemarks
+     * TODO:
+     * Figure out a way to make recursive prefilled maps work.
+     */
+    mapRecursive<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, undefined, false>;
+}
+//# sourceMappingURL=schemaFactoryRecursive.d.ts.map

package/dist/class-tree/schemaFactoryRecursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../src/class-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EACN,oBAAoB,EACpB,0CAA0C,EAC1C,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;GAMG;AACH,qBAAa,sBAAsB,CAClC,MAAM,SAAS,MAAM,EACrB,KAAK,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CACrC,SAAQ,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC;IACrC;;;;;;;;;OASG;IACI,cAAc,CAAC,KAAK,CAAC,IAAI,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC,SAAS,oBAAoB,EACnF,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,CAAC;WAkBT,SAAS,2CAA2C,CAAC,CAAC,CAAC;;IAK9D;;;;;;;;;OASG;IACI,YAAY,CAAC,IAAI,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC,SAAS,oBAAoB,EAC3E,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,CAAC;CAoBhB"}

package/dist/class-tree/schemaFactoryRecursive.js

@@ -0,0 +1,66 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaFactoryRecursive = void 0;
+const feature_libraries_1 = require("../feature-libraries");
+const schemaFactory_1 = require("./schemaFactory");
+/**
+ * Extends SchemaFactory with utilities for recursive types.
+ *
+ * @remarks This is separated from SchemaFactory as these APIs are more experimental, and may be stabilized independently.
+ *
+ * @sealed @internal
+ */
+class SchemaFactoryRecursive extends schemaFactory_1.SchemaFactory {
+    /**
+     * For unknown reasons, recursive lists work better (compile in more cases)
+     * if their constructor takes in an object with a member containing the iterable,
+     * rather than taking the iterable as a parameter directly.
+     *
+     * This version of `list` leverages this fact, and has a constructor that requires its data be passed in like:
+     * ```typescript
+     * new MyRecursiveList({x: theData});
+     * ```
+     */
+    arrayRecursive(name, allowedTypes) {
+        class RecursiveArray extends this.namedArray(name, allowedTypes, true, false) {
+            constructor(data) {
+                if ((0, feature_libraries_1.isFlexTreeNode)(data)) {
+                    super(data);
+                }
+                else {
+                    super(data.x);
+                }
+            }
+        }
+        return RecursiveArray;
+    }
+    /**
+     * For unknown reasons, recursive maps work better (compile in more cases)
+     * if their constructor does not take in the desired type.
+     *
+     * This version of `map` leverages this fact and takes in undefined instead.
+     * Unfortunately this means all maps created this way must be created empty then filled later.
+     * @privateRemarks
+     * TODO:
+     * Figure out a way to make recursive prefilled maps work.
+     */
+    mapRecursive(name, allowedTypes) {
+        class MapSchema extends this.namedMap(name, allowedTypes, true, false) {
+            constructor(data) {
+                if ((0, feature_libraries_1.isFlexTreeNode)(data)) {
+                    super(data);
+                }
+                else {
+                    super(new Map());
+                }
+            }
+        }
+        return MapSchema;
+    }
+}
+exports.SchemaFactoryRecursive = SchemaFactoryRecursive;
+//# sourceMappingURL=schemaFactoryRecursive.js.map

package/dist/class-tree/schemaFactoryRecursive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../src/class-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,4DAAoE;AASpE,mDAAgD;AAEhD;;;;;;GAMG;AACH,MAAa,sBAGX,SAAQ,6BAA4B;IACrC;;;;;;;;;OASG;IACI,cAAc,CACpB,IAAU,EACV,YAAe;QAEf,MAAM,cAAe,SAAQ,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC;YAC5E,YACC,IAAmF;gBAEnF,IAAI,IAAA,kCAAc,EAAC,IAAI,CAAC,EAAE;oBACzB,KAAK,CAAC,IAAW,CAAC,CAAC;iBACnB;qBAAM;oBACN,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBACd;YACF,CAAC;SACD;QAED,OAAO,cAMN,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACI,YAAY,CAClB,IAAU,EACV,YAAe;QAEf,MAAM,SAAU,SAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC;YACrE,YAAmB,IAA+B;gBACjD,IAAI,IAAA,kCAAc,EAAC,IAAI,CAAC,EAAE;oBACzB,KAAK,CAAC,IAAW,CAAC,CAAC;iBACnB;qBAAM;oBACN,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;iBACjB;YACF,CAAC;SACD;QAED,OAAO,SAMN,CAAC;IACH,CAAC;CACD;AAvED,wDAuEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { FlexTreeNode, isFlexTreeNode } from \"../feature-libraries\";\nimport { TreeArrayNode } from \"../simple-tree\";\nimport {\n\tImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tNodeKind,\n\tTreeMapNode,\n\tTreeNodeSchemaClass,\n} from \"./schemaTypes\";\nimport { SchemaFactory } from \"./schemaFactory\";\n\n/**\n * Extends SchemaFactory with utilities for recursive types.\n *\n * @remarks This is separated from SchemaFactory as these APIs are more experimental, and may be stabilized independently.\n *\n * @sealed @internal\n */\nexport class SchemaFactoryRecursive<\n\tTScope extends string,\n\tTName extends number | string = string,\n> extends SchemaFactory<TScope, TName> {\n\t/**\n\t * For unknown reasons, recursive lists work better (compile in more cases)\n\t * if their constructor takes in an object with a member containing the iterable,\n\t * rather than taking the iterable as a parameter directly.\n\t *\n\t * This version of `list` leverages this fact, and has a constructor that requires its data be passed in like:\n\t * ```typescript\n\t * new MyRecursiveList({x: theData});\n\t * ```\n\t */\n\tpublic arrayRecursive<const Name extends TName, const T extends ImplicitAllowedTypes>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t) {\n\t\tclass RecursiveArray extends this.namedArray(name, allowedTypes, true, false) {\n\t\t\tpublic constructor(\n\t\t\t\tdata: { x: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> } | FlexTreeNode,\n\t\t\t) {\n\t\t\t\tif (isFlexTreeNode(data)) {\n\t\t\t\t\tsuper(data as any);\n\t\t\t\t} else {\n\t\t\t\t\tsuper(data.x);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn RecursiveArray as unknown as TreeNodeSchemaClass<\n\t\t\t`${TScope}.${string}`,\n\t\t\tNodeKind.Array,\n\t\t\tTreeArrayNode<T>,\n\t\t\t{ x: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> },\n\t\t\tfalse\n\t\t>;\n\t}\n\n\t/**\n\t * For unknown reasons, recursive maps work better (compile in more cases)\n\t * if their constructor does not take in the desired type.\n\t *\n\t * This version of `map` leverages this fact and takes in undefined instead.\n\t * Unfortunately this means all maps created this way must be created empty then filled later.\n\t * @privateRemarks\n\t * TODO:\n\t * Figure out a way to make recursive prefilled maps work.\n\t */\n\tpublic mapRecursive<Name extends TName, const T extends ImplicitAllowedTypes>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t) {\n\t\tclass MapSchema extends this.namedMap(name, allowedTypes, true, false) {\n\t\t\tpublic constructor(data?: undefined | FlexTreeNode) {\n\t\t\t\tif (isFlexTreeNode(data)) {\n\t\t\t\t\tsuper(data as any);\n\t\t\t\t} else {\n\t\t\t\t\tsuper(new Map());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn MapSchema as TreeNodeSchemaClass<\n\t\t\t`${TScope}.${Name}`,\n\t\t\tNodeKind.Map,\n\t\t\tTreeMapNode<T>,\n\t\t\tundefined,\n\t\t\tfalse\n\t\t>;\n\t}\n}\n"]}

package/dist/class-tree/schemaTypes.d.ts

@@ -0,0 +1,237 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { IFluidHandle } from "@fluidframework/core-interfaces";
+import { MakeNominal, RestrictiveReadonlyRecord } from "../util";
+import { FlexListToUnion, LazyItem } from "../feature-libraries";
+import { Unhydrated, TreeMapNodeBase } from "../simple-tree";
+/**
+ * Helper used to produce types for object nodes.
+ * @beta
+ */
+export type ObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
+    -readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
+};
+/**
+ * Helper used to produce types for:
+ *
+ * 1. Insertable content which can be used to construct an object node.
+ *
+ * 2. Insertable content which is an unhydrated object node.
+ *
+ * 3. Union of 1 and 2.
+ *
+ * TODO: consider separating these cases into different types.
+ * @beta
+ */
+export type InsertableObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
+    readonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;
+};
+/**
+ * Schema for a tree node.
+ * @typeParam Name - The full (including scope) name/identifier for the schema.
+ * @typeParam Kind - Which kind of node this schema is for.
+ * @typeParam TNode - API for nodes that use this schema.
+ * @typeParam TBuild - Data which can be used to construct an unhydrated node of this type.
+ * @remarks
+ * Captures the schema both as runtime data and compile time type information.
+ * @beta
+ */
+export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable>;
+/**
+ * Schema which is not a class.
+ * @remarks
+ * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.
+ * @privateRemarks
+ * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.
+ * @beta
+ */
+export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable> {
+    create(data: TInsertable): TNode;
+}
+/**
+ * Tree node schema which is implemented using a class.
+ * @remarks
+ * Instances of this class are nodes in the tree.
+ * This is also a constructor so that it can be subclassed.
+ *
+ * Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.
+ * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer "any" in the d.ts file.
+ * @beta
+ */
+export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable> {
+    /**
+     * Constructs an {@link Unhydrated} node with this schema.
+     * @remarks
+     * This constructor is also used internally to construct hydrated nodes with a different parameter type.
+     * Therefor overriding this constructor is not type-safe and is not supported.
+     * @sealed
+     */
+    new (data: TInsertable): Unhydrated<TNode>;
+}
+/**
+ * Data common to all tree node schema.
+ * @beta
+ */
+export interface TreeNodeSchemaCore<out Name extends string, out Kind extends NodeKind, out ImplicitlyConstructable extends boolean> {
+    readonly identifier: Name;
+    readonly kind: Kind;
+    readonly info: unknown;
+    /**
+     * When constructing insertable content,
+     * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node
+     * iff implicitlyConstructable is true.
+     * @privateRemarks
+     * Currently the logic for traversing insertable content,
+     * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,
+     * so if their constructors differ from what is supported, some cases will not work.
+     * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.
+     */
+    readonly implicitlyConstructable: ImplicitlyConstructable;
+}
+/**
+ * Types for use in fields.
+ * @beta
+ */
+export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
+/**
+ * Kind of a field on a node.
+ * @beta
+ */
+export declare enum FieldKind {
+    /**
+     * A field which can be empty or filled.
+     * @remarks
+     * Allows 0 or one child.
+     */
+    Optional = 0,
+    /**
+     * A field which must always be filled.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Required = 1
+}
+/**
+ * Kind of tree node.
+ * @beta
+ */
+export declare enum NodeKind {
+    /**
+     * A node which serves as a map, storing children under string keys.
+     */
+    Map = 0,
+    /**
+     * A node which serves as an array, storing children in an ordered sequence.
+     */
+    Array = 1,
+    /**
+     * A node which stores a heterogenous collection of children in named fields.
+     * @remarks
+     * Each field gets its own schema.
+     */
+    Object = 2,
+    /**
+     * A node which stores a single leaf value.
+     */
+    Leaf = 3
+}
+/**
+ * All policy for a specific field,
+ * including functionality that does not have to be kept consistent across versions or deterministic.
+ *
+ * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
+ * @sealed @beta
+ */
+export declare class FieldSchema<out Kind extends FieldKind = FieldKind, out Types extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
+    readonly kind: Kind;
+    readonly allowedTypes: Types;
+    /**
+     * This class is used with instanceof, and therefore should have nominal typing.
+     * This field enforces that.
+     */
+    protected _typeCheck?: MakeNominal;
+    /**
+     * @param kind - The [kind](https://en.wikipedia.org/wiki/Kind_(type_theory)) of this field.
+     * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     * @param allowedTypes - What types of tree nodes are allowed in this field.
+     */
+    constructor(kind: Kind, allowedTypes: Types);
+}
+/**
+ * Types allowed in a field.
+ * @remarks
+ * Implicitly treats a single type as an array of one type.
+ * @beta
+ */
+export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
+/**
+ * Schema for a field of a tree node.
+ * @remarks
+ * Implicitly treats {@link ImplicitAllowedTypes} as a Required field of that type.
+ * @beta
+ */
+export type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
+/**
+ * Converts ImplicitFieldSchema to the corresponding tree node's field type.
+ * @beta
+ */
+export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
+/**
+ * Type of content that can be inserted into the tree for a field of the given schema.
+ * @beta
+ */
+export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
+/**
+ * Suitable for output.
+ * For input must error on side of excluding undefined instead.
+ * @beta
+ */
+export type ApplyKind<T, Kind extends FieldKind> = Kind extends FieldKind.Required ? T : undefined | T;
+/**
+ * Type of of tree node for a field of the given schema.
+ * @beta
+ */
+export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
+/**
+ * Type of content that can be inserted into the tree for a node of the given schema.
+ * @beta
+ */
+export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
+/**
+ * Takes in `TreeNodeSchema[]` and returns a TypedNode union.
+ * @beta
+ */
+export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
+/**
+ * Data which can be used as a node to be inserted.
+ * Either an unhydrated node, or content to build a new node.
+ * @beta
+ */
+export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
+    implicitlyConstructable: true;
+} ? NodeBuilderData<T> : never) | Unhydrated<NodeFromSchema<T>>;
+/**
+ * Given a node's schema, return the corresponding object from which the node could be built.
+ * @privateRemarks
+ * Currently this assumes factory functions take exactly one argument.
+ * This could be changed if needed.
+ *
+ * These factory functions can also take a FlexTreeNode, but this is not exposed in the public facing types.
+ * @beta
+ */
+export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+/**
+ * A map of string keys to tree objects.
+ *
+ * @beta
+ */
+export interface TreeMapNode<T extends ImplicitAllowedTypes> extends TreeMapNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>> {
+}
+/**
+ * Value that may be stored as a leaf node.
+ * @beta
+ */
+export type TreeLeafValue = number | string | boolean | IFluidHandle | null;
+//# sourceMappingURL=schemaTypes.d.ts.map

package/dist/class-tree/schemaTypes.d.ts.map

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

package/dist/class-tree/schemaTypes.js

@@ -0,0 +1,71 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSchema = exports.NodeKind = exports.FieldKind = void 0;
+/**
+ * Kind of a field on a node.
+ * @beta
+ */
+var FieldKind;
+(function (FieldKind) {
+    /**
+     * A field which can be empty or filled.
+     * @remarks
+     * Allows 0 or one child.
+     */
+    FieldKind[FieldKind["Optional"] = 0] = "Optional";
+    /**
+     * A field which must always be filled.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    FieldKind[FieldKind["Required"] = 1] = "Required";
+})(FieldKind || (exports.FieldKind = FieldKind = {}));
+/**
+ * Kind of tree node.
+ * @beta
+ */
+var NodeKind;
+(function (NodeKind) {
+    /**
+     * A node which serves as a map, storing children under string keys.
+     */
+    NodeKind[NodeKind["Map"] = 0] = "Map";
+    /**
+     * A node which serves as an array, storing children in an ordered sequence.
+     */
+    NodeKind[NodeKind["Array"] = 1] = "Array";
+    /**
+     * A node which stores a heterogenous collection of children in named fields.
+     * @remarks
+     * Each field gets its own schema.
+     */
+    NodeKind[NodeKind["Object"] = 2] = "Object";
+    /**
+     * A node which stores a single leaf value.
+     */
+    NodeKind[NodeKind["Leaf"] = 3] = "Leaf";
+})(NodeKind || (exports.NodeKind = NodeKind = {}));
+/**
+ * All policy for a specific field,
+ * including functionality that does not have to be kept consistent across versions or deterministic.
+ *
+ * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
+ * @sealed @beta
+ */
+class FieldSchema {
+    /**
+     * @param kind - The [kind](https://en.wikipedia.org/wiki/Kind_(type_theory)) of this field.
+     * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     * @param allowedTypes - What types of tree nodes are allowed in this field.
+     */
+    constructor(kind, allowedTypes) {
+        this.kind = kind;
+        this.allowedTypes = allowedTypes;
+    }
+}
+exports.FieldSchema = FieldSchema;
+//# sourceMappingURL=schemaTypes.js.map

package/dist/class-tree/schemaTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaTypes.js","sourceRoot":"","sources":["../../src/class-tree/schemaTypes.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAoIH;;;GAGG;AACH,IAAY,SAaX;AAbD,WAAY,SAAS;IACpB;;;;OAIG;IACH,iDAAQ,CAAA;IACR;;;;OAIG;IACH,iDAAQ,CAAA;AACT,CAAC,EAbW,SAAS,yBAAT,SAAS,QAapB;AAED;;;GAGG;AACH,IAAY,QAmBX;AAnBD,WAAY,QAAQ;IACnB;;OAEG;IACH,qCAAG,CAAA;IACH;;OAEG;IACH,yCAAK,CAAA;IACL;;;;OAIG;IACH,2CAAM,CAAA;IACN;;OAEG;IACH,uCAAI,CAAA;AACL,CAAC,EAnBW,QAAQ,wBAAR,QAAQ,QAmBnB;AAED;;;;;;GAMG;AACH,MAAa,WAAW;IAUvB;;;;OAIG;IACH,YACiB,IAAU,EACV,YAAmB;QADnB,SAAI,GAAJ,IAAI,CAAM;QACV,iBAAY,GAAZ,YAAY,CAAO;IACjC,CAAC;CACJ;AAnBD,kCAmBC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { MakeNominal, RestrictiveReadonlyRecord } from \"../util\";\nimport { FlexListToUnion, LazyItem } from \"../feature-libraries\";\nimport { Unhydrated, TreeMapNodeBase } from \"../simple-tree\";\n\n/**\n * Helper used to produce types for object nodes.\n * @beta\n */\nexport type ObjectFromSchemaRecord<\n\tT extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,\n> = {\n\t-readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;\n};\n\n/**\n * Helper used to produce types for:\n *\n * 1. Insertable content which can be used to construct an object node.\n *\n * 2. Insertable content which is an unhydrated object node.\n *\n * 3. Union of 1 and 2.\n *\n * TODO: consider separating these cases into different types.\n * @beta\n */\nexport type InsertableObjectFromSchemaRecord<\n\tT extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,\n> = {\n\treadonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;\n};\n\n/**\n * Schema for a tree node.\n * @typeParam Name - The full (including scope) name/identifier for the schema.\n * @typeParam Kind - Which kind of node this schema is for.\n * @typeParam TNode - API for nodes that use this schema.\n * @typeParam TBuild - Data which can be used to construct an unhydrated node of this type.\n * @remarks\n * Captures the schema both as runtime data and compile time type information.\n * @beta\n */\nexport type TreeNodeSchema<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode = unknown,\n\tTBuild = never,\n\tImplicitlyConstructable extends boolean = boolean,\n> =\n\t| TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable>\n\t| TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable>;\n\n/**\n * Schema which is not a class.\n * @remarks\n * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.\n * @privateRemarks\n * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.\n * @beta\n */\nexport interface TreeNodeSchemaNonClass<\n\tout Name extends string = string,\n\tout Kind extends NodeKind = NodeKind,\n\tout TNode = unknown,\n\tin TInsertable = never,\n\tout ImplicitlyConstructable extends boolean = boolean,\n> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable> {\n\tcreate(data: TInsertable): TNode;\n}\n\n/**\n * Tree node schema which is implemented using a class.\n * @remarks\n * Instances of this class are nodes in the tree.\n * This is also a constructor so that it can be subclassed.\n *\n * Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.\n * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer \"any\" in the d.ts file.\n * @beta\n */\nexport interface TreeNodeSchemaClass<\n\tout Name extends string = string,\n\tout Kind extends NodeKind = NodeKind,\n\tout TNode = unknown,\n\tin TInsertable = never,\n\tout ImplicitlyConstructable extends boolean = boolean,\n> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable> {\n\t/**\n\t * Constructs an {@link Unhydrated} node with this schema.\n\t * @remarks\n\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t * Therefor overriding this constructor is not type-safe and is not supported.\n\t * @sealed\n\t */\n\tnew (data: TInsertable): Unhydrated<TNode>;\n}\n\n/**\n * Data common to all tree node schema.\n * @beta\n */\nexport interface TreeNodeSchemaCore<\n\tout Name extends string,\n\tout Kind extends NodeKind,\n\tout ImplicitlyConstructable extends boolean,\n> {\n\treadonly identifier: Name;\n\treadonly kind: Kind;\n\treadonly info: unknown;\n\n\t/**\n\t * When constructing insertable content,\n\t * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node\n\t * iff implicitlyConstructable is true.\n\t * @privateRemarks\n\t * Currently the logic for traversing insertable content,\n\t * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,\n\t * so if their constructors differ from what is supported, some cases will not work.\n\t * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.\n\t */\n\treadonly implicitlyConstructable: ImplicitlyConstructable;\n}\n\n/**\n * Types for use in fields.\n * @beta\n */\nexport type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];\n\n/**\n * Kind of a field on a node.\n * @beta\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}\n\n/**\n * Kind of tree node.\n * @beta\n */\nexport enum NodeKind {\n\t/**\n\t * A node which serves as a map, storing children under string keys.\n\t */\n\tMap,\n\t/**\n\t * A node which serves as an array, storing children in an ordered sequence.\n\t */\n\tArray,\n\t/**\n\t * A node which stores a heterogenous collection of children in named fields.\n\t * @remarks\n\t * Each field gets its own schema.\n\t */\n\tObject,\n\t/**\n\t * A node which stores a single leaf value.\n\t */\n\tLeaf,\n}\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 * @sealed @beta\n */\nexport class FieldSchema<\n\tout Kind extends FieldKind = FieldKind,\n\tout Types extends ImplicitAllowedTypes = ImplicitAllowedTypes,\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\t/**\n\t * @param kind - The [kind](https://en.wikipedia.org/wiki/Kind_(type_theory)) of this field.\n\t * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.\n\t * @param allowedTypes - What types of tree nodes are allowed in this field.\n\t */\n\tpublic constructor(\n\t\tpublic readonly kind: Kind,\n\t\tpublic readonly allowedTypes: Types,\n\t) {}\n}\n\n/**\n * Types allowed in a field.\n * @remarks\n * Implicitly treats a single type as an array of one type.\n * @beta\n */\nexport type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;\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 * @beta\n */\nexport type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;\n\n/**\n * Converts ImplicitFieldSchema to the corresponding tree node's field type.\n * @beta\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? TreeNodeFromImplicitAllowedTypes<TSchema>\n\t\t: unknown;\n\n/**\n * Type of content that can be inserted into the tree for a field of the given schema.\n * @beta\n */\nexport type InsertableTreeFieldFromImplicitField<\n\tTSchema extends ImplicitFieldSchema = FieldSchema,\n> = TSchema extends FieldSchema<infer Kind, infer Types>\n\t? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind>\n\t: TSchema extends ImplicitAllowedTypes\n\t? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>\n\t: unknown;\n\n/**\n * Suitable for output.\n * For input must error on side of excluding undefined instead.\n * @beta\n */\nexport type ApplyKind<T, Kind extends FieldKind> = Kind extends FieldKind.Required\n\t? T\n\t: undefined | T;\n\n/**\n * Type of of tree node for a field of the given schema.\n * @beta\n */\nexport type TreeNodeFromImplicitAllowedTypes<\n\tTSchema extends ImplicitAllowedTypes = TreeNodeSchema,\n> = TSchema extends TreeNodeSchema\n\t? NodeFromSchema<TSchema>\n\t: TSchema extends AllowedTypes\n\t? NodeFromSchema<FlexListToUnion<TSchema>>\n\t: unknown;\n\n/**\n * Type of content that can be inserted into the tree for a node of the given schema.\n * @beta\n */\nexport type InsertableTreeNodeFromImplicitAllowedTypes<\n\tTSchema extends ImplicitAllowedTypes = TreeNodeSchema,\n> = TSchema extends TreeNodeSchema\n\t? InsertableTypedNode<TSchema>\n\t: TSchema extends AllowedTypes\n\t? InsertableTypedNode<FlexListToUnion<TSchema>>\n\t: never;\n\n/**\n * Takes in `TreeNodeSchema[]` and returns a TypedNode union.\n * @beta\n */\nexport type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<\n\tstring,\n\tNodeKind,\n\tinfer TNode\n>\n\t? TNode\n\t: never;\n\n/**\n * Data which can be used as a node to be inserted.\n * Either an unhydrated node, or content to build a new node.\n * @beta\n */\nexport type InsertableTypedNode<T extends TreeNodeSchema> =\n\t| (T extends { implicitlyConstructable: true } ? NodeBuilderData<T> : never)\n\t| Unhydrated<NodeFromSchema<T>>;\n\n/**\n * Given a node's schema, return the corresponding object from which the node could be built.\n * @privateRemarks\n * Currently this assumes factory functions take exactly one argument.\n * This could be changed if needed.\n *\n * These factory functions can also take a FlexTreeNode, but this is not exposed in the public facing types.\n * @beta\n */\nexport type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<\n\tstring,\n\tNodeKind,\n\tunknown,\n\tinfer TBuild\n>\n\t? TBuild\n\t: never;\n\n/**\n * A map of string keys to tree objects.\n *\n * @beta\n */\nexport interface TreeMapNode<T extends ImplicitAllowedTypes>\n\textends TreeMapNodeBase<\n\t\tTreeNodeFromImplicitAllowedTypes<T>,\n\t\tInsertableTreeNodeFromImplicitAllowedTypes<T>\n\t> {}\n\n/**\n * Value that may be stored as a leaf node.\n * @beta\n */\n// eslint-disable-next-line @rushstack/no-new-null\nexport type TreeLeafValue = number | string | boolean | IFluidHandle | null;\n"]}

package/dist/class-tree/testRecursiveDomain.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type NodeKind as _dummy } from "./schemaTypes";
+/**
+ * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.
+ * Ideally this would be inlined into the class definition below.
+ *
+ * TODO:
+ * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).
+ * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol "RecursiveObject_base" needs to be exported by the entry point index.d.ts
+ * See https://github.com/microsoft/rushstack/issues/4429
+ * @internal
+ */
+export declare const base: import("./schemaTypes").TreeNodeSchemaClass<"Test Recursive Domain.testObject", _dummy.Object, import("./schemaTypes").ObjectFromSchemaRecord<{
+    readonly recursive: import("./schemaTypes").FieldSchema<import("./schemaTypes").FieldKind.Optional, readonly [() => typeof RecursiveObject]>;
+    readonly number: import("./schemaTypes").TreeNodeSchema<"com.fluidframework.leaf.number", _dummy.Leaf, number, number>;
+}>, import("./schemaTypes").InsertableObjectFromSchemaRecord<{
+    readonly recursive: import("./schemaTypes").FieldSchema<import("./schemaTypes").FieldKind.Optional, readonly [() => typeof RecursiveObject]>;
+    readonly number: import("./schemaTypes").TreeNodeSchema<"com.fluidframework.leaf.number", _dummy.Leaf, number, number>;
+}>, true>;
+/**
+ * @internal
+ */
+export declare class RecursiveObject extends base {
+}
+//# sourceMappingURL=testRecursiveDomain.d.ts.map

package/dist/class-tree/testRecursiveDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testRecursiveDomain.d.ts","sourceRoot":"","sources":["../../src/class-tree/testRecursiveDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,KAAK,QAAQ,IAAI,MAAM,EAAE,MAAM,eAAe,CAAC;AAYxD;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI;;;;;;SAGf,CAAC;AAEH;;GAEG;AACH,qBAAa,eAAgB,SAAQ,IAAI;CAAG"}

package/dist/class-tree/testRecursiveDomain.js

@@ -0,0 +1,40 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecursiveObject = exports.base = void 0;
+/**
+ * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.
+ * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).
+ * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get "any" instead of the recursive type reference.
+ * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.
+ */
+const schemaFactoryRecursive_1 = require("./schemaFactoryRecursive");
+{
+}
+const builder = new schemaFactoryRecursive_1.SchemaFactoryRecursive("Test Recursive Domain");
+const recursiveReference = () => RecursiveObject;
+builder.fixRecursiveReference(recursiveReference);
+/**
+ * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.
+ * Ideally this would be inlined into the class definition below.
+ *
+ * TODO:
+ * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).
+ * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol "RecursiveObject_base" needs to be exported by the entry point index.d.ts
+ * See https://github.com/microsoft/rushstack/issues/4429
+ * @internal
+ */
+exports.base = builder.object("testObject", {
+    recursive: builder.optional([recursiveReference]),
+    number: builder.number,
+});
+/**
+ * @internal
+ */
+class RecursiveObject extends exports.base {
+}
+exports.RecursiveObject = RecursiveObject;
+//# sourceMappingURL=testRecursiveDomain.js.map

package/dist/class-tree/testRecursiveDomain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testRecursiveDomain.js","sourceRoot":"","sources":["../../src/class-tree/testRecursiveDomain.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;GAKG;AAEH,qEAAkE;AAMlE;CAGC;AAED,MAAM,OAAO,GAAG,IAAI,+CAAsB,CAAC,uBAAuB,CAAC,CAAC;AAEpE,MAAM,kBAAkB,GAAG,GAAG,EAAE,CAAC,eAAe,CAAC;AACjD,OAAO,CAAC,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;AAElD;;;;;;;;;GASG;AACU,QAAA,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE;IAChD,SAAS,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC;IACjD,MAAM,EAAE,OAAO,CAAC,MAAM;CACtB,CAAC,CAAC;AAEH;;GAEG;AACH,MAAa,eAAgB,SAAQ,YAAI;CAAG;AAA5C,0CAA4C","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.\n * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).\n * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get \"any\" instead of the recursive type reference.\n * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.\n */\n\nimport { SchemaFactoryRecursive } from \"./schemaFactoryRecursive\";\n// This type is referred to by the base type generated by builder.object.\n// Adding the import of it here prevents TypeScript from generating inline includes for it in the d.ts file.\n// If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.\nimport { type NodeKind as _dummy } from \"./schemaTypes\";\n\n{\n\t// Unused imports are an error, so make an unused type to use it.\n\ttype _X = _dummy;\n}\n\nconst builder = new SchemaFactoryRecursive(\"Test Recursive Domain\");\n\nconst recursiveReference = () => RecursiveObject;\nbuilder.fixRecursiveReference(recursiveReference);\n\n/**\n * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.\n * Ideally this would be inlined into the class definition below.\n *\n * TODO:\n * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).\n * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol \"RecursiveObject_base\" needs to be exported by the entry point index.d.ts\n * See https://github.com/microsoft/rushstack/issues/4429\n * @internal\n */\nexport const base = builder.object(\"testObject\", {\n\trecursive: builder.optional([recursiveReference]),\n\tnumber: builder.number,\n});\n\n/**\n * @internal\n */\nexport class RecursiveObject extends base {}\n"]}

package/dist/class-tree/toFlexSchema.d.ts

@@ -0,0 +1,58 @@
+import { FlexTreeSchema, TreeFieldSchema as FlexTreeFieldSchema, AllowedTypes as FlexAllowedTypes, TreeNodeSchemaBase as FlexTreeNodeSchemaBase, TreeNodeSchema as FlexTreeNodeSchema } from "../feature-libraries";
+import { ITreeCursorSynchronous, TreeNodeSchemaIdentifier } from "../core";
+import { type InitializeAndSchematizeConfiguration } from "../shared-tree";
+import { ImplicitAllowedTypes, ImplicitFieldSchema, InsertableTreeNodeFromImplicitAllowedTypes, TreeNodeSchema } from "./schemaTypes";
+import { TreeConfiguration } from "./tree";
+/**
+ * Returns a cursor (in nodes mode) for the root node.
+ *
+ * @privateRemarks
+ * Ideally this would work on any node, not just the root,
+ * and the schema would come from the unhydrated node.
+ * For now though, this is the only case that's needed, and we do have the data to make it work, so this is fine.
+ */
+export declare function cursorFromUnhydratedRoot(schema: FlexTreeSchema, tree: InsertableTreeNodeFromImplicitAllowedTypes): ITreeCursorSynchronous;
+export declare function toFlexConfig(config: TreeConfiguration): InitializeAndSchematizeConfiguration;
+interface SchemaInfo {
+    toFlex: () => FlexTreeNodeSchema;
+    original: TreeNodeSchema;
+}
+type SchemaMap = Map<TreeNodeSchemaIdentifier, SchemaInfo>;
+/**
+ * Generate a {@link FlexTreeSchema} with `root` as the root field.
+ *
+ * This also has the side effect of populating the cached view schema on the class based schema.
+ */
+export declare function toFlexSchema(root: ImplicitFieldSchema): FlexTreeSchema;
+/**
+ * Return a flex schema for the provided class schema.
+ *
+ * This also has the side effect of populating the cached view schema on the class based schema.
+ */
+export declare function getFlexSchema(root: TreeNodeSchema): FlexTreeNodeSchema;
+/**
+ * Normalizes an {@link ImplicitFieldSchema} into a {@link TreeFieldSchema}.
+ */
+export declare function convertField(schemaMap: SchemaMap, schema: ImplicitFieldSchema): FlexTreeFieldSchema;
+/**
+ * Normalizes an {@link ImplicitAllowedTypes} into an {@link AllowedTypes}.
+ */
+export declare function convertAllowedTypes(schemaMap: SchemaMap, schema: ImplicitAllowedTypes): FlexAllowedTypes;
+/**
+ * Converts a {@link TreeNodeSchema} into a {@link FlexTreeNodeSchema}.
+ * Ensures all types reachable from `schema` are included in `schemaMap`.
+ *
+ * Return value (and entries in map) are lazy to allow recursive types to work.
+ * This laziness does NOT extend to adding entries to `schemaMap`:
+ * all referenced types are added to it before this function returns.
+ */
+export declare function convertNodeSchema(schemaMap: SchemaMap, schema: TreeNodeSchema): () => FlexTreeNodeSchema;
+/**
+ * A symbol for storing FlexTreeSchema on TreeNodeSchema.
+ * Eagerly set on leaves, and lazily set for other cases.
+ */
+export declare const flexSchemaSymbol: unique symbol;
+export declare function cachedFlexSchemaFromClassSchema(schema: TreeNodeSchema): FlexTreeNodeSchemaBase | undefined;
+export declare function setFlexSchemaFromClassSchema(simple: TreeNodeSchema, flex: FlexTreeNodeSchemaBase): void;
+export {};
+//# sourceMappingURL=toFlexSchema.d.ts.map

package/dist/class-tree/toFlexSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toFlexSchema.d.ts","sourceRoot":"","sources":["../../src/class-tree/toFlexSchema.ts"],"names":[],"mappings":"AAMA,OAAO,EACN,cAAc,EACd,eAAe,IAAI,mBAAmB,EAGtC,YAAY,IAAI,gBAAgB,EAChC,kBAAkB,IAAI,sBAAsB,EAC5C,cAAc,IAAI,kBAAkB,EAMpC,MAAM,sBAAsB,CAAC;AAS9B,OAAO,EAAqB,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAC9F,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,EAGN,oBAAoB,EACpB,mBAAmB,EACnB,0CAA0C,EAE1C,cAAc,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,0CAA0C,GAC9C,sBAAsB,CAMxB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,oCAAoC,CAU5F;AAED,UAAU,UAAU;IACnB,MAAM,EAAE,MAAM,kBAAkB,CAAC;IACjC,QAAQ,EAAE,cAAc,CAAC;CACzB;AAED,KAAK,SAAS,GAAG,GAAG,CAAC,wBAAwB,EAAE,UAAU,CAAC,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,cAAc,CA0BtE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,GAAG,kBAAkB,CAGtE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC3B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,mBAAmB,GACzB,mBAAmB,CAYrB;AAOD;;GAEG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,oBAAoB,GAC1B,gBAAgB,CAKlB;AAID;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,cAAc,GACpB,MAAM,kBAAkB,CAqF1B;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAA6B,CAAC;AAEpE,wBAAgB,+BAA+B,CAC9C,MAAM,EAAE,cAAc,GACpB,sBAAsB,GAAG,SAAS,CAEpC;AAED,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,sBAAsB,GAC1B,IAAI,CAEN"}