@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -4,16 +4,28 @@
  */
 import { Unenforced } from "../feature-libraries/index.js";
 import { RestrictiveReadonlyRecord } from "../util/index.js";
-import { FieldKind, FieldSchema, ImplicitAllowedTypes, ImplicitFieldSchema, InsertableObjectFromSchemaRecord, InsertableTreeNodeFromImplicitAllowedTypes, NodeKind, TreeNodeSchema, TreeNodeSchemaClass, WithType } from "./schemaTypes.js";
-import { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
+import { InsertableObjectFromSchemaRecord } from "./objectNode.js";
+import { FieldKind, ImplicitAllowedTypes, ImplicitFieldSchema, InsertableTreeNodeFromImplicitAllowedTypes, NodeKind, TreeNodeSchemaClass, WithType } from "./schemaTypes.js";
 import { TreeNode } from "./types.js";
-import { FieldSchemaUnsafe, InsertableObjectFromSchemaRecordUnsafe, InsertableTreeNodeFromImplicitAllowedTypesUnsafe, ObjectFromSchemaRecordUnsafe, TreeArrayNodeUnsafe, TreeMapNodeUnsafe } from "./typesUnsafe.js";
+import { FieldSchemaUnsafe } from "./typesUnsafe.js";
 export declare function createFieldSchemaUnsafe<Kind extends FieldKind, Types extends Unenforced<ImplicitAllowedTypes>>(kind: Kind, allowedTypes: Types): FieldSchemaUnsafe<Kind, Types>;
 /**
- * Extends SchemaFactory with utilities for recursive schema.
- * @see {@link ValidateRecursiveSchema}
+ * Compile time check for validity of a recursive schema.
+ *
+ * @example
+ * ```typescript
+ * class Test extends sf.arrayRecursive("Test", [() => Test]) {}
+ * {
+ *     type _check = ValidateRecursiveSchema<typeof Test>;
+ * }
+ * ```
  * @remarks
- * This is separated from {@link SchemaFactory} as these APIs are more experimental and may be stabilized independently.
+ * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases of malformed schema.
+ * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.
+ * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,
+ * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).
+ *
+ * # Recursive Schema
  *
  * The non-recursive versions of the schema building methods will run into several issues when used recursively.
  * Consider the following example:
@@ -32,7 +44,7 @@ export declare function createFieldSchemaUnsafe<Kind extends FieldKind, Types ex
  * This would be a runtime error if the TypeScript compiler allowed it.
  * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).
  *
- * 3. TypeScript fails to infer the recursive type and falls back to `any` with the warning or error (depending on the compiler configuration):
+ * 3. TypeScript fails to infer the recursive type and falls back to `any` with this warning or error (depending on the compiler configuration):
  * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.
  * This issue is what the specialized recursive schema building methods fix.
  * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.
@@ -42,7 +54,7 @@ export declare function createFieldSchemaUnsafe<Kind extends FieldKind, Types ex
  * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.
  *
  * 4. It is using "POJO" mode since it's not explicitly declaring a new class.
- * This means that if the schema generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.
+ * This means that the generated d.ts files for the schema replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.
  * This is fixed by explicitly creating a class which extends the returned schema.
  *
  * All together, the fixed version looks like:
@@ -59,97 +71,29 @@ export declare function createFieldSchemaUnsafe<Kind extends FieldKind, Types ex
  * class Test extends sf.arrayRecursive("Test", () => Test) {} // Bad
  * ```
  * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.
- * This issue can be partially mitigated using {@link ValidateRecursiveSchema}.
- * @sealed @beta
- */
-export declare class SchemaFactoryRecursive<TScope extends string, TName extends number | string = string> extends SchemaFactory<TScope, TName> {
-    /**
-     * {@link SchemaFactory.object} except tweaked to work better for recursive types.
-     * @remarks
-     * This version of {@link SchemaFactory.object} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     */
-    objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecordUnsafe<T>, false, T>;
-    /**
-     * {@link SchemaFactory.optional} except tweaked to work better for recursive types.
-     * @remarks
-     * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     */
-    optionalRecursive<const T extends Unenforced<readonly (() => TreeNodeSchema)[]>>(t: T): FieldSchemaUnsafe<FieldKind.Optional, T>;
-    /**
-     * `SchemaFactory.array` except tweaked to work better for recursive types.
-     * @remarks
-     * This version of `SchemaFactory.array` has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     *
-     * Additionally `ImplicitlyConstructable` is disabled (forcing use of constructor) to avoid
-     * `error TS2589: Type instantiation is excessively deep and possibly infinite.`
-     * which otherwise gets reported at sometimes incorrect source locations that vary based on incremental builds.
-     */
-    arrayRecursive<const Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>, {
-        /**
-         * Iterator for the iterable of content for this node.
-         * @privateRemarks
-         * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
-         * the following compile error when declaring the recursive schema:
-         * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
-         * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
-         *
-         * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
-         * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
-         */
-        [Symbol.iterator](): Iterator<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>;
-    }, false, T>;
-    /**
-     * `SchemaFactory.map` except tweaked to work better for recursive types.
-     * @remarks
-     * This version of `SchemaFactory.map` uses the same workarounds as {@link SchemaFactoryRecursive.arrayRecursive}
-     */
-    mapRecursive<Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>, {
-        /**
-         * Iterator for the iterable of content for this node.
-         * @privateRemarks
-         * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
-         * the following compile error when declaring the recursive schema:
-         * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
-         * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
-         *
-         * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
-         * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
-         */
-        [Symbol.iterator](): Iterator<[
-            string,
-            InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>
-        ]>;
-    }, false, T>;
-}
-/**
- * Compile time check for validity of a recursive schema.
+ * This issue can be partially mitigated using {@link ValidateRecursiveSchema}:
  *
- * @example
  * ```typescript
- * class Test extends sf.arrayRecursive("Test", [() => Test]) {}
+ * class Test extends sf.arrayRecursive("Test", () => Test) {} // Bad
  * {
- *     type _check = ValidateRecursiveSchema<typeof Test>;
+ *     type _check = ValidateRecursiveSchema<typeof Test>; // Reports compile error due to invalid schema above.
  * }
  * ```
- * @remarks
- * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases which the schema in malformed.
- * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.
- * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,
- * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).
+ *
  * @privateRemarks
  * There are probably mistakes this misses: it's hard to guess all the wrong things people will accidentally do and defend against them.
  * Hopefully over time this can grow toward being robust, at least for common mistakes.
  *
  * This check duplicates logic that ideally would be entirely decided by the actual schema building methods.
  * Therefore changes to those methods may require updating `ValidateRecursiveSchema`.
- * @beta
+ * @public
  */
 export type ValidateRecursiveSchema<T extends TreeNodeSchemaClass<string, NodeKind.Array | NodeKind.Map | NodeKind.Object, TreeNode & WithType<T["identifier"]>, {
-    [NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<string, FieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
+    [NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
     [NodeKind.Array]: T["info"] extends ImplicitAllowedTypes ? Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>> : unknown;
     [NodeKind.Map]: T["info"] extends ImplicitAllowedTypes ? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>]> : unknown;
 }[T["kind"]], false, {
-    [NodeKind.Object]: RestrictiveReadonlyRecord<string, FieldSchema>;
+    [NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;
     [NodeKind.Array]: ImplicitAllowedTypes;
     [NodeKind.Map]: ImplicitAllowedTypes;
 }[T["kind"]]>> = true;

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

@@ -1 +1 @@
-{"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AAEnE,OAAO,EACN,SAAS,EAET,oBAAoB,EACpB,mBAAmB,EACnB,0CAA0C,EAC1C,QAAQ,EACR,mBAAmB,EACnB,QAAQ,EACR,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,wBAAgB,uBAAuB,CACtC,IAAI,SAAS,SAAS,EACtB,KAAK,SAAS,UAAU,CAAC,oBAAoB,CAAC,EAC7C,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,GAAG,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,CAMjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,MAAM,MAAM,uBAAuB,CAElC,CAAC,SAAS,mBAAmB,CAE5B,MAAM,EAEN,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,MAAM,EAE/C,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,EAGpC;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,yBAAyB,CAC7D,MAAM,EACN,mBAAmB,CACnB,GACE,gCAAgC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAC3C,OAAO,CAAC;IACX,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,oBAAoB,GACrD,QAAQ,CAAC,0CAA0C,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAC/D,OAAO,CAAC;IACX,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,oBAAoB,GACnD,QAAQ,CAAC,CAAC,MAAM,EAAE,0CAA0C,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACzE,OAAO,CAAC;CACX,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAEZ,KAAK,EAEL;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC1E,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IACvC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CACZ,IACE,IAAI,CAAC"}

package/dist/simple-tree/schemaFactoryRecursive.js

@@ -4,125 +4,11 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaFactoryRecursive = exports.createFieldSchemaUnsafe = void 0;
-const index_js_1 = require("../feature-libraries/index.js");
+exports.createFieldSchemaUnsafe = void 0;
 const schemaTypes_js_1 = require("./schemaTypes.js");
-const schemaFactory_js_1 = require("./schemaFactory.js");
 function createFieldSchemaUnsafe(kind, allowedTypes) {
     // At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe
     return new schemaTypes_js_1.FieldSchema(kind, allowedTypes);
 }
 exports.createFieldSchemaUnsafe = createFieldSchemaUnsafe;
-/**
- * Extends SchemaFactory with utilities for recursive schema.
- * @see {@link ValidateRecursiveSchema}
- * @remarks
- * This is separated from {@link SchemaFactory} as these APIs are more experimental and may be stabilized independently.
- *
- * The non-recursive versions of the schema building methods will run into several issues when used recursively.
- * Consider the following example:
- *
- * ```typescript
- * const Test = sf.array(Test); // Bad
- * ```
- *
- * This has several issues:
- *
- * 1. It is a structurally named schema.
- * Structurally named schema derive their name from the names of their child types, which is not possible when the type is recursive since its name would include itself.
- * Instead a name must be explicitly provided.
- *
- * 2. The schema accesses itself before it's defined.
- * This would be a runtime error if the TypeScript compiler allowed it.
- * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).
- *
- * 3. TypeScript fails to infer the recursive type and falls back to `any` with the warning or error (depending on the compiler configuration):
- * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.
- * This issue is what the specialized recursive schema building methods fix.
- * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.
- * This means that mistakes declaring recursive schema often don't give compile errors in the schema.
- * Additionally support for implicit construction had to be disabled.
- * This means that new nested {@link Unhydrated} nodes can not be created like `new Test([[]])`.
- * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.
- *
- * 4. It is using "POJO" mode since it's not explicitly declaring a new class.
- * This means that if the schema generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.
- * This is fixed by explicitly creating a class which extends the returned schema.
- *
- * All together, the fixed version looks like:
- * ```typescript
- * class Test extends sf.arrayRecursive("Test", [() => Test]) {} // Good
- * ```
- *
- * Be very careful when declaring recursive schema.
- * Due to the removed extends clauses, subtle mistakes will compile just fine but cause strange errors when the schema is used.
- *
- * For example if the square brackets around the allowed types are forgotten:
- *
- * ```typescript
- * class Test extends sf.arrayRecursive("Test", () => Test) {} // Bad
- * ```
- * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.
- * This issue can be partially mitigated using {@link ValidateRecursiveSchema}.
- * @sealed @beta
- */
-class SchemaFactoryRecursive extends schemaFactory_js_1.SchemaFactory {
-    /**
-     * {@link SchemaFactory.object} except tweaked to work better for recursive types.
-     * @remarks
-     * This version of {@link SchemaFactory.object} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     */
-    objectRecursive(name, t) {
-        return this.object(name, t);
-    }
-    /**
-     * {@link SchemaFactory.optional} except tweaked to work better for recursive types.
-     * @remarks
-     * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     */
-    optionalRecursive(t) {
-        return createFieldSchemaUnsafe(schemaTypes_js_1.FieldKind.Optional, t);
-    }
-    /**
-     * `SchemaFactory.array` except tweaked to work better for recursive types.
-     * @remarks
-     * This version of `SchemaFactory.array` has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-     *
-     * Additionally `ImplicitlyConstructable` is disabled (forcing use of constructor) to avoid
-     * `error TS2589: Type instantiation is excessively deep and possibly infinite.`
-     * which otherwise gets reported at sometimes incorrect source locations that vary based on incremental builds.
-     */
-    arrayRecursive(name, allowedTypes) {
-        class RecursiveArray extends this.namedArray_internal(name, allowedTypes, true, false) {
-            constructor(data) {
-                if ((0, index_js_1.isFlexTreeNode)(data)) {
-                    super(data);
-                }
-                else {
-                    super(data);
-                }
-            }
-        }
-        return RecursiveArray;
-    }
-    /**
-     * `SchemaFactory.map` except tweaked to work better for recursive types.
-     * @remarks
-     * This version of `SchemaFactory.map` uses the same workarounds as {@link SchemaFactoryRecursive.arrayRecursive}
-     */
-    mapRecursive(name, allowedTypes) {
-        class MapSchema extends this.namedMap_internal(name, allowedTypes, true, false) {
-            constructor(data) {
-                if ((0, index_js_1.isFlexTreeNode)(data)) {
-                    super(data);
-                }
-                else {
-                    super(new Map(data));
-                }
-            }
-        }
-        return MapSchema;
-    }
-}
-exports.SchemaFactoryRecursive = SchemaFactoryRecursive;
 //# sourceMappingURL=schemaFactoryRecursive.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,4DAAyF;AAEzF,qDAW0B;AAC1B,yDAA0E;AAW1E,SAAgB,uBAAuB,CAGrC,IAAU,EAAE,YAAmB;IAChC,kJAAkJ;IAClJ,OAAO,IAAI,4BAAW,CAAC,IAAI,EAAE,YAAoC,CAGhE,CAAC;AACH,CAAC;AATD,0DASC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAa,sBAGX,SAAQ,gCAA4B;IACrC;;;;OAIG;IACI,eAAe,CAGpB,IAAU,EAAE,CAAI;QACjB,OAAO,IAAI,CAAC,MAAM,CACjB,IAAI,EACJ,CAA+D,CAQ/D,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CAAgE,CAAI;QAC3F,OAAO,uBAAuB,CAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvD,CAAC;IAED;;;;;;;;OAQG;IACI,cAAc,CAGnB,IAAU,EAAE,YAAe;QAC5B,MAAM,cAAe,SAAQ,IAAI,CAAC,mBAAmB,CACpD,IAAI,EACJ,YAAwC,EACxC,IAAI,EACJ,KAAK,CACL;YACA,YACC,IAEe;gBAEf,IAAI,IAAA,yBAAc,EAAC,IAAI,CAAC,EAAE;oBACzB,KAAK,CAAC,IAAW,CAAC,CAAC;iBACnB;qBAAM;oBACN,KAAK,CAAC,IAAI,CAAC,CAAC;iBACZ;YACF,CAAC;SACD;QAED,OAAO,cAoBN,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,YAAY,CAClB,IAAU,EACV,YAAe;QAEf,MAAM,SAAU,SAAQ,IAAI,CAAC,iBAAiB,CAC7C,IAAI,EACJ,YAAwC,EACxC,IAAI,EACJ,KAAK,CACL;YACA,YACC,IASe;gBAEf,IAAI,IAAA,yBAAc,EAAC,IAAI,CAAC,EAAE;oBACzB,KAAK,CAAC,IAAW,CAAC,CAAC;iBACnB;qBAAM;oBACN,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;iBACrB;YACF,CAAC;SACD;QAED,OAAO,SAsBN,CAAC;IACH,CAAC;CACD;AArJD,wDAqJC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { FlexTreeNode, Unenforced, isFlexTreeNode } from \"../feature-libraries/index.js\";\nimport { RestrictiveReadonlyRecord } from \"../util/index.js\";\nimport {\n\tFieldKind,\n\tFieldSchema,\n\tImplicitAllowedTypes,\n\tImplicitFieldSchema,\n\tInsertableObjectFromSchemaRecord,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tNodeKind,\n\tTreeNodeSchema,\n\tTreeNodeSchemaClass,\n\tWithType,\n} from \"./schemaTypes.js\";\nimport { SchemaFactory, type ScopedSchemaName } from \"./schemaFactory.js\";\nimport { TreeNode } from \"./types.js\";\nimport {\n\tFieldSchemaUnsafe,\n\tInsertableObjectFromSchemaRecordUnsafe,\n\tInsertableTreeNodeFromImplicitAllowedTypesUnsafe,\n\tObjectFromSchemaRecordUnsafe,\n\tTreeArrayNodeUnsafe,\n\tTreeMapNodeUnsafe,\n} from \"./typesUnsafe.js\";\n\nexport function createFieldSchemaUnsafe<\n\tKind extends FieldKind,\n\tTypes extends Unenforced<ImplicitAllowedTypes>,\n>(kind: Kind, allowedTypes: Types): FieldSchemaUnsafe<Kind, Types> {\n\t// At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe\n\treturn new FieldSchema(kind, allowedTypes as ImplicitAllowedTypes) as FieldSchemaUnsafe<\n\t\tKind,\n\t\tTypes\n\t>;\n}\n\n/**\n * Extends SchemaFactory with utilities for recursive schema.\n * @see {@link ValidateRecursiveSchema}\n * @remarks\n * This is separated from {@link SchemaFactory} as these APIs are more experimental and may be stabilized independently.\n *\n * The non-recursive versions of the schema building methods will run into several issues when used recursively.\n * Consider the following example:\n *\n * ```typescript\n * const Test = sf.array(Test); // Bad\n * ```\n *\n * This has several issues:\n *\n * 1. It is a structurally named schema.\n * Structurally named schema derive their name from the names of their child types, which is not possible when the type is recursive since its name would include itself.\n * Instead a name must be explicitly provided.\n *\n * 2. The schema accesses itself before it's defined.\n * This would be a runtime error if the TypeScript compiler allowed it.\n * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).\n *\n * 3. TypeScript fails to infer the recursive type and falls back to `any` with the warning or error (depending on the compiler configuration):\n * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.\n * This issue is what the specialized recursive schema building methods fix.\n * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.\n * This means that mistakes declaring recursive schema often don't give compile errors in the schema.\n * Additionally support for implicit construction had to be disabled.\n * This means that new nested {@link Unhydrated} nodes can not be created like `new Test([[]])`.\n * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.\n *\n * 4. It is using \"POJO\" mode since it's not explicitly declaring a new class.\n * This means that if the schema generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.\n * This is fixed by explicitly creating a class which extends the returned schema.\n *\n * All together, the fixed version looks like:\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {} // Good\n * ```\n *\n * Be very careful when declaring recursive schema.\n * Due to the removed extends clauses, subtle mistakes will compile just fine but cause strange errors when the schema is used.\n *\n * For example if the square brackets around the allowed types are forgotten:\n *\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", () => Test) {} // Bad\n * ```\n * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.\n * This issue can be partially mitigated using {@link ValidateRecursiveSchema}.\n * @sealed @beta\n */\nexport class SchemaFactoryRecursive<\n\tTScope extends string,\n\tTName extends number | string = string,\n> extends SchemaFactory<TScope, TName> {\n\t/**\n\t * {@link SchemaFactory.object} except tweaked to work better for recursive types.\n\t * @remarks\n\t * This version of {@link SchemaFactory.object} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t */\n\tpublic objectRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,\n\t>(name: Name, t: T) {\n\t\treturn this.object(\n\t\t\tname,\n\t\t\tt as T & RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,\n\t\t) as unknown as TreeNodeSchemaClass<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tNodeKind.Object,\n\t\t\tTreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\t\tobject & InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n\n\t/**\n\t * {@link SchemaFactory.optional} except tweaked to work better for recursive types.\n\t * @remarks\n\t * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t */\n\tpublic optionalRecursive<const T extends Unenforced<readonly (() => TreeNodeSchema)[]>>(t: T) {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Optional, t);\n\t}\n\n\t/**\n\t * `SchemaFactory.array` except tweaked to work better for recursive types.\n\t * @remarks\n\t * This version of `SchemaFactory.array` has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t *\n\t * Additionally `ImplicitlyConstructable` is disabled (forcing use of constructor) to avoid\n\t * `error TS2589: Type instantiation is excessively deep and possibly infinite.`\n\t * which otherwise gets reported at sometimes incorrect source locations that vary based on incremental builds.\n\t */\n\tpublic arrayRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends Unenforced<ImplicitAllowedTypes>,\n\t>(name: Name, allowedTypes: T) {\n\t\tclass RecursiveArray extends this.namedArray_internal(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\ttrue,\n\t\t\tfalse,\n\t\t) {\n\t\t\tpublic constructor(\n\t\t\t\tdata:\n\t\t\t\t\t| Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T & ImplicitAllowedTypes>>\n\t\t\t\t\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);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn RecursiveArray as TreeNodeSchemaClass<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tNodeKind.Array,\n\t\t\tTreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\t\t{\n\t\t\t\t/**\n\t\t\t\t * Iterator for the iterable of content for this node.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)\n\t\t\t\t * the following compile error when declaring the recursive schema:\n\t\t\t\t * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`\n\t\t\t\t * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.\n\t\t\t\t *\n\t\t\t\t * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.\n\t\t\t\t * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.\n\t\t\t\t */\n\t\t\t\t[Symbol.iterator](): Iterator<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>;\n\t\t\t},\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n\n\t/**\n\t * `SchemaFactory.map` except tweaked to work better for recursive types.\n\t * @remarks\n\t * This version of `SchemaFactory.map` uses the same workarounds as {@link SchemaFactoryRecursive.arrayRecursive}\n\t */\n\tpublic mapRecursive<Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t) {\n\t\tclass MapSchema extends this.namedMap_internal(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\ttrue,\n\t\t\tfalse,\n\t\t) {\n\t\t\tpublic constructor(\n\t\t\t\tdata:\n\t\t\t\t\t| Iterable<\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\tstring,\n\t\t\t\t\t\t\t\tInsertableTreeNodeFromImplicitAllowedTypes<\n\t\t\t\t\t\t\t\t\tT & ImplicitAllowedTypes\n\t\t\t\t\t\t\t\t>,\n\t\t\t\t\t\t\t]\n\t\t\t\t\t  >\n\t\t\t\t\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(new Map(data));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn MapSchema as TreeNodeSchemaClass<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tNodeKind.Map,\n\t\t\tTreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\t\t{\n\t\t\t\t/**\n\t\t\t\t * Iterator for the iterable of content for this node.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)\n\t\t\t\t * the following compile error when declaring the recursive schema:\n\t\t\t\t * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`\n\t\t\t\t * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.\n\t\t\t\t *\n\t\t\t\t * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.\n\t\t\t\t * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.\n\t\t\t\t */\n\t\t\t\t[Symbol.iterator](): Iterator<\n\t\t\t\t\t[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]\n\t\t\t\t>;\n\t\t\t},\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n}\n\n/**\n * Compile time check for validity of a recursive schema.\n *\n * @example\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {}\n * {\n *     type _check = ValidateRecursiveSchema<typeof Test>;\n * }\n * ```\n * @remarks\n * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases which the schema in malformed.\n * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.\n * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,\n * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).\n * @privateRemarks\n * There are probably mistakes this misses: it's hard to guess all the wrong things people will accidentally do and defend against them.\n * Hopefully over time this can grow toward being robust, at least for common mistakes.\n *\n * This check duplicates logic that ideally would be entirely decided by the actual schema building methods.\n * Therefore changes to those methods may require updating `ValidateRecursiveSchema`.\n * @beta\n */\nexport type ValidateRecursiveSchema<\n\t// Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as thats part of the requirements for the type to work across compilation boundaries correctly.\n\tT extends TreeNodeSchemaClass<\n\t\t// Name: This validator places no restrictions on the name other than that it's a string (as required by TreeNodeSchemaClass).\n\t\tstring,\n\t\t// NodeKind: These are the NodeKinds which currently can be used recursively.\n\t\tNodeKind.Array | NodeKind.Map | NodeKind.Object,\n\t\t// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.\n\t\tTreeNode & WithType<T[\"identifier\"]>,\n\t\t// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.\n\t\t// These match whats defined in the methods on `SchemaFactoryRecursive` except they do not use `Unenforced`.\n\t\t{\n\t\t\t[NodeKind.Object]: T[\"info\"] extends RestrictiveReadonlyRecord<string, FieldSchema>\n\t\t\t\t? InsertableObjectFromSchemaRecord<T[\"info\"]>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Array]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Map]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>]>\n\t\t\t\t: unknown;\n\t\t}[T[\"kind\"]],\n\t\t// ImplicitlyConstructable: recursive types are not implicitly constructable.\n\t\tfalse,\n\t\t// Info: What's passed to the method to create the schema. Constraining these here should be about as effective as if the actual constraints existed on the actual method itself.\n\t\t{\n\t\t\t[NodeKind.Object]: RestrictiveReadonlyRecord<string, FieldSchema>;\n\t\t\t[NodeKind.Array]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Map]: ImplicitAllowedTypes;\n\t\t}[T[\"kind\"]]\n\t>,\n> = true;\n"]}
+{"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAMH,qDAS0B;AAI1B,SAAgB,uBAAuB,CAGrC,IAAU,EAAE,YAAmB;IAChC,kJAAkJ;IAClJ,OAAO,IAAI,4BAAW,CAAC,IAAI,EAAE,YAAoC,CAGhE,CAAC;AACH,CAAC;AATD,0DASC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Unenforced } from \"../feature-libraries/index.js\";\nimport { RestrictiveReadonlyRecord } from \"../util/index.js\";\nimport { InsertableObjectFromSchemaRecord } from \"./objectNode.js\";\n\nimport {\n\tFieldKind,\n\tFieldSchema,\n\tImplicitAllowedTypes,\n\tImplicitFieldSchema,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tNodeKind,\n\tTreeNodeSchemaClass,\n\tWithType,\n} from \"./schemaTypes.js\";\nimport { TreeNode } from \"./types.js\";\nimport { FieldSchemaUnsafe } from \"./typesUnsafe.js\";\n\nexport function createFieldSchemaUnsafe<\n\tKind extends FieldKind,\n\tTypes extends Unenforced<ImplicitAllowedTypes>,\n>(kind: Kind, allowedTypes: Types): FieldSchemaUnsafe<Kind, Types> {\n\t// At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe\n\treturn new FieldSchema(kind, allowedTypes as ImplicitAllowedTypes) as FieldSchemaUnsafe<\n\t\tKind,\n\t\tTypes\n\t>;\n}\n\n/**\n * Compile time check for validity of a recursive schema.\n *\n * @example\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {}\n * {\n *     type _check = ValidateRecursiveSchema<typeof Test>;\n * }\n * ```\n * @remarks\n * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases of malformed schema.\n * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.\n * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,\n * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).\n *\n * # Recursive Schema\n *\n * The non-recursive versions of the schema building methods will run into several issues when used recursively.\n * Consider the following example:\n *\n * ```typescript\n * const Test = sf.array(Test); // Bad\n * ```\n *\n * This has several issues:\n *\n * 1. It is a structurally named schema.\n * Structurally named schema derive their name from the names of their child types, which is not possible when the type is recursive since its name would include itself.\n * Instead a name must be explicitly provided.\n *\n * 2. The schema accesses itself before it's defined.\n * This would be a runtime error if the TypeScript compiler allowed it.\n * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).\n *\n * 3. TypeScript fails to infer the recursive type and falls back to `any` with this warning or error (depending on the compiler configuration):\n * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.\n * This issue is what the specialized recursive schema building methods fix.\n * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.\n * This means that mistakes declaring recursive schema often don't give compile errors in the schema.\n * Additionally support for implicit construction had to be disabled.\n * This means that new nested {@link Unhydrated} nodes can not be created like `new Test([[]])`.\n * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.\n *\n * 4. It is using \"POJO\" mode since it's not explicitly declaring a new class.\n * This means that the generated d.ts files for the schema replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.\n * This is fixed by explicitly creating a class which extends the returned schema.\n *\n * All together, the fixed version looks like:\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {} // Good\n * ```\n *\n * Be very careful when declaring recursive schema.\n * Due to the removed extends clauses, subtle mistakes will compile just fine but cause strange errors when the schema is used.\n *\n * For example if the square brackets around the allowed types are forgotten:\n *\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", () => Test) {} // Bad\n * ```\n * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.\n * This issue can be partially mitigated using {@link ValidateRecursiveSchema}:\n *\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", () => Test) {} // Bad\n * {\n *     type _check = ValidateRecursiveSchema<typeof Test>; // Reports compile error due to invalid schema above.\n * }\n * ```\n *\n * @privateRemarks\n * There are probably mistakes this misses: it's hard to guess all the wrong things people will accidentally do and defend against them.\n * Hopefully over time this can grow toward being robust, at least for common mistakes.\n *\n * This check duplicates logic that ideally would be entirely decided by the actual schema building methods.\n * Therefore changes to those methods may require updating `ValidateRecursiveSchema`.\n * @public\n */\nexport type ValidateRecursiveSchema<\n\t// Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as thats part of the requirements for the type to work across compilation boundaries correctly.\n\tT extends TreeNodeSchemaClass<\n\t\t// Name: This validator places no restrictions on the name other than that it's a string (as required by TreeNodeSchemaClass).\n\t\tstring,\n\t\t// NodeKind: These are the NodeKinds which currently can be used recursively.\n\t\tNodeKind.Array | NodeKind.Map | NodeKind.Object,\n\t\t// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.\n\t\tTreeNode & WithType<T[\"identifier\"]>,\n\t\t// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.\n\t\t// These match whats defined in the recursive methods on `SchemaFactory` except they do not use `Unenforced`.\n\t\t{\n\t\t\t[NodeKind.Object]: T[\"info\"] extends RestrictiveReadonlyRecord<\n\t\t\t\tstring,\n\t\t\t\tImplicitFieldSchema\n\t\t\t>\n\t\t\t\t? InsertableObjectFromSchemaRecord<T[\"info\"]>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Array]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Map]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>]>\n\t\t\t\t: unknown;\n\t\t}[T[\"kind\"]],\n\t\t// ImplicitlyConstructable: recursive types are not implicitly constructable.\n\t\tfalse,\n\t\t// Info: What's passed to the method to create the schema. Constraining these here should be about as effective as if the actual constraints existed on the actual method itself.\n\t\t{\n\t\t\t[NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;\n\t\t\t[NodeKind.Array]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Map]: ImplicitAllowedTypes;\n\t\t}[T[\"kind\"]]\n\t>,\n> = true;\n"]}

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

@@ -3,37 +3,10 @@
  * Licensed under the MIT License.
  */
 import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { MakeNominal, RestrictiveReadonlyRecord } from "../util/index.js";
 import { FlexListToUnion, LazyItem } from "../feature-libraries/index.js";
-import { Unhydrated, TreeNode } from "./types.js";
-/**
- * Helper used to produce types for object nodes.
- * @public
- */
-export type ObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
-    -readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
-};
-/**
- * Helper used to produce types for object nodes.
- * @public
- */
-export type TreeObjectNode<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = object & TreeNode & ObjectFromSchemaRecord<T>;
-/**
- * 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.
- *
- * @privateRemarks TODO: consider separating these cases into different types.
- *
- * @public
- */
-export type InsertableObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
-    readonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;
-};
+import { MakeNominal } from "../util/index.js";
+import { Unhydrated } from "./types.js";
+import { FieldKey } from "../core/index.js";
 /**
  * Schema for a tree node.
  * @typeParam Name - The full (including scope) name/identifier for the schema.
@@ -125,7 +98,13 @@ export declare enum FieldKind {
      * @remarks
      * Only allows exactly one child.
      */
-    Required = 1
+    Required = 1,
+    /**
+     * A special field used for node identifiers.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Identifier = 2
 }
 /**
  * Kind of tree node.
@@ -151,6 +130,78 @@ export declare enum NodeKind {
      */
     Leaf = 3
 }
+/**
+ * Maps from a view key to its corresponding {@link FieldProps.key | stored key} for the provided
+ * {@link ImplicitFieldSchema | field schema}.
+ *
+ * @remarks
+ * If an explicit stored key was specified in the schema, it will be used.
+ * Otherwise, the stored key is the same as the view key.
+ */
+export declare function getStoredKey(viewKey: string, fieldSchema: ImplicitFieldSchema): FieldKey;
+/**
+ * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
+ * Otherwise, returns undefined.
+ */
+export declare function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined;
+/**
+ * Additional information to provide to a {@link FieldSchema}.
+ *
+ * @public
+ */
+export interface FieldProps {
+    /**
+     * The unique identifier of a field, used in the persisted form of the tree.
+     *
+     * @remarks
+     * If not explicitly set via the schema, this is the same as the schema's property key.
+     *
+     * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.
+     * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,
+     * you can change the property key and specify the previous property key as the stored key.
+     *
+     * Notes:
+     *
+     * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`
+     * will always return the property keys specified in the schema, ignoring any stored keys that differ from
+     * the property keys.
+     *
+     * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys
+     * (accounting for those implicitly derived from property keys) contains no duplicates.
+     * This is validated at runtime.
+     *
+     * @example Refactoring code without breaking compatibility with existing data
+     *
+     * Consider some existing object schema:
+     *
+     * ```TypeScript
+     * class Point extends schemaFactory.object("Point", {
+     * 	xPosition: schemaFactory.number,
+     * 	yPosition: schemaFactory.number,
+     * 	zPosition: schemaFactory.optional(schemaFactory.number),
+     * });
+     * ```
+     *
+     * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.
+     *
+     * We would like to refactor the schema to omit "Position" from the property keys, but application data has
+     * already been persisted using the original property keys. To maintain compatibility with existing data,
+     * we can refactor the schema as follows:
+     *
+     * ```TypeScript
+     * class Point extends schemaFactory.object("Point", {
+     * 	x: schemaFactory.required(schemaFactory.number, { key: "xPosition" }),
+     * 	y: schemaFactory.required(schemaFactory.number, { key: "yPosition" }),
+     * 	z: schemaFactory.optional(schemaFactory.number, { key: "zPosition" }),
+     * });
+     * ```
+     *
+     * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.
+     *
+     * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.
+     */
+    readonly key?: string;
+}
 /**
  * All policy for a specific field,
  * including functionality that does not have to be kept consistent across versions or deterministic.
@@ -159,20 +210,57 @@ export declare enum NodeKind {
  * @sealed @public
  */
 export declare class FieldSchema<out Kind extends FieldKind = FieldKind, out Types extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
+    /**
+     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
+     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     */
     readonly kind: Kind;
+    /**
+     * What types of tree nodes are allowed in this field.
+     */
     readonly allowedTypes: Types;
+    /**
+     * Optional properties associated with the field.
+     */
+    readonly props?: FieldProps | undefined;
     /**
      * This class is used with instanceof, and therefore should have nominal typing.
      * This field enforces that.
      */
     protected _typeCheck?: MakeNominal;
+    private readonly lazyTypes;
     /**
-     * @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.
+     * What types of tree nodes are allowed in this field.
+     * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.
      */
-    constructor(kind: Kind, allowedTypes: Types);
+    get allowedTypeSet(): ReadonlySet<TreeNodeSchema>;
+    constructor(
+    /**
+     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
+     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     */
+    kind: Kind, 
+    /**
+     * What types of tree nodes are allowed in this field.
+     */
+    allowedTypes: Types, 
+    /**
+     * Optional properties associated with the field.
+     */
+    props?: FieldProps | undefined);
 }
+/**
+ * Normalizes a {@link ImplicitFieldSchema} to a {@link FieldSchema}.
+ */
+export declare function normalizeFieldSchema(schema: ImplicitFieldSchema): FieldSchema;
+/**
+ * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any
+ * lazy schema declarations.
+ *
+ * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ */
+export declare function normalizeAllowedTypes(types: ImplicitAllowedTypes): ReadonlySet<TreeNodeSchema>;
 /**
  * Types allowed in a field.
  * @remarks
@@ -236,41 +324,6 @@ export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
  * @public
  */
 export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
-/**
- * A map of string keys to tree objects.
- *
- * @privateRemarks
- * Add support for `clear` once we have established merge semantics for it.
- *
- * @public
- */
-export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>, TreeNode {
-    /**
-     * Adds or updates an entry in the map with a specified `key` and a `value`.
-     *
-     * @param key - The key of the element to add to the map.
-     * @param value - The value of the element to add to the map.
-     *
-     * @remarks
-     * Setting the value at a key to `undefined` is equivalent to calling {@link TreeMapNode.delete} with that key.
-     */
-    set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T> | undefined): void;
-    /**
-     * Removes the specified element from this map by its `key`.
-     *
-     * @remarks
-     * Note: unlike JavaScript's Map API, this method does not return a flag indicating whether or not the value was
-     * deleted.
-     *
-     * @privateRemarks
-     * Regarding the choice to not return a boolean: Since this data structure is distributed in nature, it isn't
-     * possible to tell whether or not the item was deleted as a result of this method call. Returning a "best guess"
-     * is more likely to create issues / promote bad usage patterns than offer useful information.
-     *
-     * @param key - The key of the element to remove from the map.
-     */
-    delete(key: string): void;
-}
 /**
  * Value that may be stored as a leaf node.
  * @public

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

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