npm - @fluidframework/tree - Versions diffs - 2.62.0 → 2.63.0-359286 - Mend

@fluidframework/tree 2.62.0 → 2.63.0-359286

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

Files changed (352) hide show

package/dist/simple-tree/api/schemaFactoryAlpha.d.ts CHANGED Viewed

@@ -2,11 +2,11 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { type ArrayNodeCustomizableSchema, type MapNodeCustomizableSchema, type ObjectNodeSchema, type RecordNodeCustomizableSchema, type RecordNodeInsertableData, type TreeRecordNode } from "../node-kinds/index.js";
+import { type ArrayNodeCustomizableSchema, type MapNodeCustomizableSchema, type ObjectNodeSchema, type RecordNodeCustomizableSchema } from "../node-kinds/index.js";
 import { type NodeSchemaOptionsAlpha, type SchemaFactoryObjectOptions, type ScopedSchemaName } from "./schemaFactory.js";
 import type { ImplicitAnnotatedFieldSchema } from "../fieldSchema.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
-import type { NodeKind, TreeNodeSchema, TreeNodeSchemaClass, TreeNodeSchemaNonClass, WithType, ImplicitAllowedTypes, ImplicitAnnotatedAllowedTypes, AnnotatedAllowedType, LazyItem } from "../core/index.js";
+import type { NodeKind, TreeNodeSchema, TreeNodeSchemaClass, ImplicitAllowedTypes, ImplicitAnnotatedAllowedTypes, AnnotatedAllowedType, LazyItem, WithType } from "../core/index.js";
 import type { ArrayNodeCustomizableSchemaUnsafe, MapNodeCustomizableSchemaUnsafe, System_Unsafe, TreeRecordNodeUnsafe } from "./typesUnsafe.js";
 import type { SimpleObjectNodeSchema } from "../simpleSchema.js";
 import { SchemaFactoryBeta } from "./schemaFactoryBeta.js";
@@ -26,8 +26,9 @@ export interface SchemaStaticsAlpha {
      * Declares a staged type in a set of {@link AllowedTypes}.
      *
      * @remarks
-     * Staged allowed types add support for loading documents which may or may not permit an allowed type in a location in a schema.
+     * Staged allowed types add support for loading documents which may contain that type at the declared location.
      * This allows for an incremental rollout of a schema change to add a {@link TreeNodeSchema} to an {@link AllowedTypes} without breaking cross version collaboration.
+     * A guide on this process can be found here: https://fluidframework.com/docs/data-structures/tree/schema-evolution/allowed-types-rollout
      *
      * Once enough clients have the type staged (and thus can read documents which allow it), documents can start being created and upgraded to allow the staged type.
      * This is done by deploying a new version of the app which removes the `staged` wrapper around the allowed type in the the schema definition.
@@ -38,107 +39,17 @@ export interface SchemaStaticsAlpha {
      * 1. {@link TreeView.initialize} will omit the staged allowed type from the newly created stored schema.
      * 2. {@link TreeView.upgradeSchema} will omit the staged allowed type from the the upgraded stored schema.
      * 3. When evaluating {@link TreeView.compatibility}, it will be viewable even if the staged allowed type is not present in the stored schema's corresponding allowed types.
-     * 4. Because of the above, it is possible to get errors when inserting content which uses the staged allowed type when inserting the content into a tree who's stored schema does not permit it.
+     * 4. Because of the above, it is possible to get errors when inserting content which uses the staged allowed type into a tree whose stored schema does not permit it.
      *
      * Currently, `staged` is not supported in the recursive type APIs: this is a known limitation which future versions of the API will address.
      *
      * @example
-     * Suppose you have a schema which has a field that allows some type `A`, but you want to add support for type `B`.
+     * A full code example of the schema migration process can be found in our {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts | tests}.
      *
-     * The first change is to used to mark the new type as staged, replacing `A` in the schema with `[A, SchemaStaticsAlpha.staged(B)]`.
-     * Once this is done, and any code which reads contents from documents is updated to handle any `B` content that may be present, this version of the code can be deployed.
-     *
-     * Once all users have the above changes, the schema can be updated again to `[A, B]`, and the app can be updated to allow creating of `B` content.
-     * This updated version of the app will need to call {@link TreeView.upgradeSchema} when opening documents created by earlier versions.
-     *
-     * Adding a `B` schema as an option in the root could look like this:
-     * ```typescript
-     * const factory = new SchemaFactoryAlpha("test");
-     * class A extends factory.objectAlpha("A", {}) {}
-     * class B extends factory.objectAlpha("B", {}) {}
-     *
-     * // Does not support B
-     * const configBefore = new TreeViewConfigurationAlpha({
-     * 	schema: A,
-     * });
-     *
-     * // Supports documents with or without B
-     * const configStaged = new TreeViewConfigurationAlpha({
-     * 	// Adds staged support for B.
-     * 	// Currently this requires wrapping the root field with `SchemaFactoryAlpha.required`:
-     * 	// this is normally implicitly included, but is currently required while the "staged" APIs are `@alpha`.
-     * 	schema: SchemaFactoryAlpha.required([A, SchemaFactoryAlpha.staged(B)]),
-     * });
-     *
-     * // Only supports documents with A and B: can be used to upgrade schema to add B.
-     * const configAfter = new TreeViewConfigurationAlpha({
-     * 	schema: [A, B],
-     * });
-     * ```
-     * @example
-     * Below is a full example of how the schema migration process works.
-     * This can also be found in our {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts | tests}.
-     * ```typescript
-     * // Schema A: only number allowed
-     * const schemaA = SchemaFactoryAlpha.optional([SchemaFactoryAlpha.number]);
-     *
-     * // Schema B: number or string (string is staged)
-     * const schemaB = SchemaFactoryAlpha.optional([
-     * 	SchemaFactoryAlpha.number,
-     * 	SchemaFactoryAlpha.staged(SchemaFactoryAlpha.string),
-     * ]);
-     *
-     * // Schema C: number or string, both fully allowed
-     * const schemaC = SchemaFactoryAlpha.optional([
-     * 	SchemaFactoryAlpha.number,
-     * 	SchemaFactoryAlpha.string,
-     * ]);
-     *
-     * // Initialize with schema A.
-     * const configA = new TreeViewConfiguration({
-     * 	schema: schemaA,
-     * });
-     * const viewA = treeA.viewWith(configA);
-     * viewA.initialize(5);
-     *
-     * // Since we are running all the different versions of the app in the same process making changes synchronously,
-     * // an explicit flush is needed to make them available to each other.
-     * synchronizeTrees();
-     *
-     * assert.deepEqual(viewA.root, 5);
-     *
-     * // View the same document with a second tree using schema B.
-     * const configB = new TreeViewConfiguration({
-     * 	schema: schemaB,
-     * });
-     * const viewB = treeB.viewWith(configB);
-     * // B cannot write strings to the root.
-     * assert.throws(() => (viewB.root = "test"));
-     *
-     * // View the same document with a third tree using schema C.
-     * const configC = new TreeViewConfiguration({
-     * 	schema: schemaC,
-     * });
-     * const viewC = treeC.viewWith(configC);
-     * // Upgrade to schema C
-     * viewC.upgradeSchema();
-     * // Use the newly enabled schema.
-     * viewC.root = "test";
-     *
-     * synchronizeTrees();
-     *
-     * // View A is now incompatible with the stored schema:
-     * assert.equal(viewA.compatibility.canView, false);
-     *
-     * // View B can still read the document, and now sees the string root which relies on the staged schema.
-     * assert.deepEqual(viewB.root, "test");
-     * ```
      * @privateRemarks
      * TODO:#44317 staged allowed types rely on schema validation of stored schema to output errors, these errors are not very
      * user friendly and should be improved, particularly in the case of staged allowed types
      *
-     * TODO: the example above does not work tell in intellisense: its formatted to work onm the website. We should find a solution that works well for both.
-     *
      * TODO: AB#45711: Update the docs above when recursive type support is added.
      */
     staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
@@ -277,76 +188,6 @@ export declare class SchemaFactoryAlpha<out TScope extends string | undefined =
      * {@inheritDoc SchemaFactory.objectRecursive}
      */
     arrayRecursive<const Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
-    /**
-     * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
-     *
-     * @param allowedTypes - The types that may appear in the record.
-     *
-     * @remarks
-     * The identifier for this record is defined as a function of the provided types.
-     * It is still scoped to this `SchemaFactory`, but multiple calls with the same arguments will return the same
-     * schema object, providing somewhat structural typing.
-     * This does not support recursive types.
-     *
-     * If using these structurally named records, other types in this schema builder should avoid names of the form `Record<${string}>`.
-     *
-     * @example
-     * The returned schema should be used as a schema directly:
-     * ```typescript
-     * const MyRecord = factory.record(factory.number);
-     * type MyRecord = NodeFromSchema<typeof Record>;
-     * ```
-     * Or inline:
-     * ```typescript
-     * factory.object("Foo", { myRecord: factory.record(factory.number) });
-     * ```
-     *
-     * @privateRemarks
-     * The name produced at the type-level here is not as specific as it could be; however, doing type-level sorting and escaping is a real mess.
-     * There are cases where not having this full type provided will be less than ideal, since TypeScript's structural types will allow assignment between runtime incompatible types at compile time.
-     * For example, attempts to narrow unions of structural records by name won't work.
-     * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
-     * though there may still be some problematic cases even after that work is done.
-     *
-     * The return value is a class, but its type is intentionally not specific enough to indicate it is a class.
-     * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls to this different subclasses)
-     * when working with structural typing.
-     *
-     * {@label STRUCTURAL}
-     */
-    record<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
-    /**
-     * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     * @param allowedTypes - The types that may appear in the record.
-     *
-     * @remarks
-     * Like TypeScript `Record`s, record nodes have some potential pitfalls.
-     * For example: TypeScript makes assumptions about built-in keys being present (e.g. `toString`, `hasOwnProperty`, etc.).
-     * Since these are otherwise valid keys in a record, this can lead to unexpected behavior.
-     * To prevent inconsistent behavior, these built-ins are hidden by record nodes.
-     * This means that if you try to call these built-ins (e.g. `toString()`) on a record node, you will get an error.
-     *
-     * In most cases, it is probably preferable to use {@link SchemaFactory.(map:2)} instead.
-     *
-     * @example
-     * ```typescript
-     * class NamedRecord extends factory.record("name", factory.number) {}
-     * ```
-     *
-     * {@label NAMED}
-     */
-    record<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @remarks
-     * This is not intended to be used directly, use the overload of `record` which takes a name instead.
-     */
-    private namedRecord;
     /**
      * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
      *
@@ -361,7 +202,7 @@ export declare class SchemaFactoryAlpha<out TScope extends string | undefined =
      */
     recordAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
     /**
-     * {@link SchemaFactoryAlpha.(record:2)} except tweaked to work better for recursive types.
+     * {@link SchemaFactoryBeta.(record:2)} except tweaked to work better for recursive types.
      * Use with {@link ValidateRecursiveSchema} for improved type safety.
      * @remarks
      * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.

package/dist/simple-tree/api/schemaFactoryAlpha.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryAlpha.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryAlpha.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,KAAK,2BAA2B,EAEhC,KAAK,yBAAyB,EAE9B,KAAK,gBAAgB,EAErB,KAAK,4BAA4B,~~EACjC~~,~~KAAK,wBAAwB,EAE7B,KAAK,cAAc,EACnB,~~MAAM,wBAAwB,CAAC;AAChC,OAAO,~~EAIN~~,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,4BAA4B,EAAuB,MAAM,mBAAmB,CAAC;AAC3F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EACX,QAAQ,EACR,cAAc,~~EAEd~~,mBAAmB,EACnB,~~sBAAsB,EACtB,QAAQ,EACR,~~oBAAoB,EACpB,6BAA6B,EAC7B,oBAAoB,EACpB,QAAQ,EACR,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACX,iCAAiC,EACjC,+BAA+B,EAC/B,aAAa,EACb,oBAAoB,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAI3D,OAAO,KAAK,EACX,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAG/D;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAClC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsHG~~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~~IAEI~~,eAAe,~~CACrB~~,IAAI,SAAS,KAAK,EAClB,KAAK,CAAC,CAAC,SAAS,aAAa,CAAC,0BAA0B,EACxD,KAAK,CAAC,eAAe,GAAG,OAAO,EAC9B,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,sBAAsB,CAAC,eAAe,CAAC;;;~~IA8BhF~~;;OAEG;IACI,kBAAkB,CACxB,KAAK,CAAC,CAAC,SAAS,KAAK,EACrB,UAAU,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC1C,IAAI,EAAE,CAAC,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC;CAGvE"}
1	+ {"version":3,"file":"schemaFactoryAlpha.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryAlpha.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/api/schemaFactoryAlpha.js CHANGED Viewed

@@ -122,44 +122,6 @@ class SchemaFactoryAlpha extends schemaFactoryBeta_js_1.SchemaFactoryBeta {
     arrayRecursive(name, allowedTypes, options) {
         return this.arrayAlpha(name, allowedTypes, options);
     }
-    /**
-     * {@link SchemaFactory.array} implementation.
-     *
-     * @privateRemarks
-     * This should return TreeNodeSchemaBoth: see note on "map" implementation for details.
-     */
-    record(nameOrAllowedTypes, maybeAllowedTypes) {
-        if (maybeAllowedTypes === undefined) {
-            const types = nameOrAllowedTypes;
-            const fullName = (0, schemaFactory_js_1.structuralName)("Record", types);
-            return this.getStructuralType(fullName, types, () => this.namedRecord(fullName, nameOrAllowedTypes,
-            /* customizable */ false,
-            /* implicitlyConstructable */ true));
-        }
-        const out = this.namedRecord(nameOrAllowedTypes, maybeAllowedTypes,
-        /* customizable */ true,
-        /* implicitlyConstructable */ true);
-        return out;
-    }
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @remarks
-     * This is not intended to be used directly, use the overload of `record` which takes a name instead.
-     */
-    namedRecord(name, allowedTypes, customizable, implicitlyConstructable, options) {
-        const record = (0, index_js_1.recordSchema)({
-            identifier: (0, schemaFactory_js_1.scoped)(this, name),
-            info: allowedTypes,
-            customizable,
-            implicitlyConstructable,
-            metadata: options?.metadata,
-            persistedMetadata: options?.persistedMetadata,
-        });
-        return record;
-    }
     /**
      * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
      *
@@ -183,7 +145,7 @@ class SchemaFactoryAlpha extends schemaFactoryBeta_js_1.SchemaFactoryBeta {
         });
     }
     /**
-     * {@link SchemaFactoryAlpha.(record:2)} except tweaked to work better for recursive types.
+     * {@link SchemaFactoryBeta.(record:2)} except tweaked to work better for recursive types.
      * Use with {@link ValidateRecursiveSchema} for improved type safety.
      * @remarks
      * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.
@@ -191,11 +153,16 @@ class SchemaFactoryAlpha extends schemaFactoryBeta_js_1.SchemaFactoryBeta {
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
     recordRecursive(name, allowedTypes, options) {
-        const RecordSchema = this.namedRecord(name, allowedTypes,
-        /* customizable */ true,
-        // Setting this to true seems to work ok currently, but not for other node kinds.
-        // Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
-        /* implicitlyConstructable */ false, options);
+        const RecordSchema = (0, index_js_1.recordSchema)({
+            identifier: (0, schemaFactory_js_1.scoped)(this, name),
+            info: allowedTypes,
+            customizable: true,
+            // Setting this to true seems to work ok currently, but not for other node kinds.
+            // Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
+            implicitlyConstructable: false,
+            metadata: options?.metadata,
+            persistedMetadata: options?.persistedMetadata,
+        });
         return RecordSchema;
     }
     /**

package/dist/simple-tree/api/schemaFactoryAlpha.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryAlpha.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryAlpha.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qDAWgC;AAChC,yDAO4B;AAC5B,yDAAmD;AAenD,+CAAwF;AAQxF,iEAA2D;AAmJ3D,MAAM,kBAAkB,GAAuB;IAC9C,MAAM,EAAE,CACP,CAA8B,EACJ,EAAE;QAC5B,MAAM,aAAa,GAAG,IAAA,0CAA+B,EAAC,CAAC,CAAC,CAAC;QACzD,OAAO;YACN,IAAI,EAAE,aAAa,CAAC,IAAI;YACxB,QAAQ,EAAE;gBACT,GAAG,aAAa,CAAC,QAAQ;gBACzB,mBAAmB,EAAE,IAAA,8BAAmB,GAAE;aAC1C;SACD,CAAC;IACH,CAAC;CACD,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAa,kBAGX,SAAQ,wCAAgC;IAH1C;;QAiIC;;WAEG;QACsB,WAAM,GAAG,gCAAa,CAAC,MAAM,CAAC;QAEvD;;WAEG;QACsB,aAAQ,GAAG,gCAAa,CAAC,QAAQ,CAAC;QAE3D;;WAEG;QACsB,aAAQ,GAAG,gCAAa,CAAC,QAAQ,CAAC;QAE3D;;WAEG;QACsB,sBAAiB,GAAG,gCAAa,CAAC,iBAAiB,CAAC;QAE7E;;WAEG;QACsB,sBAAiB,GAAG,gCAAa,CAAC,iBAAiB,CAAC;QAO7E;;WAEG;QACI,WAAM,GAAG,kBAAkB,CAAC,MAAM,CAAC;IAuX3C,CAAC;IArhBA;;;;;;OAMG;IACI,WAAW,CAKjB,IAAU,EACV,MAAS,EACT,OAAqD;QAcrD,OAAO,IAAA,uBAAY,EAClB,IAAA,yBAAM,EAAsB,IAAI,EAAE,IAAI,CAAC,EACvC,MAAM,EACN,IAAI,EACJ,OAAO,EAAE,0BAA0B;YAClC,oDAAiC,CAAC,0BAA0B,EAC7D,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,iBAAiB,CAC1B,CAAC;IACH,CAAC;IAED;;OAEG;IACa,eAAe,CAK9B,IAAU,EACV,CAAI,EACJ,OAAqD;QAwBrD,OAAO,IAAI,CAAC,WAAW,CACtB,IAAI,EACJ,CAAqD,EACrD,OAAO,CAgBN,CAAC;IACJ,CAAC;IAmED;;;;;;;;;;;;;OAaG;IACI,QAAQ,CAKd,IAAU,EACV,YAAe,EACf,OAAiD;QAEjD,OAAO,IAAA,oBAAS,EACf,IAAA,yBAAM,EAAsB,IAAI,EAAE,IAAI,CAAC,EACvC,YAAY,EACZ,IAAI,EACJ,IAAI,EACJ,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,iBAAiB,CAC1B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,4EAA4E;IAC5D,YAAY,CAI1B,IAAU,EAAE,YAAe,EAAE,OAAiD;QAC/E,OAAO,IAAI,CAAC,QAAQ,CACnB,IAAI,EACJ,YAAwC,EACxC,OAAO,CAKP,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACI,UAAU,CAKhB,IAAU,EACV,YAAe,EACf,OAAiD;QAEjD,OAAO,IAAA,sBAAW,EACjB,IAAA,yBAAM,EAAsB,IAAI,EAAE,IAAI,CAAC,EACvC,YAAY,EACZ,IAAI,EACJ,IAAI,EACJ,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,iBAAiB,CAC1B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,4EAA4E;IAC5D,cAAc,CAI5B,IAAU,EAAE,YAAe,EAAE,OAAiD;QAC/E,OAAO,IAAI,CAAC,UAAU,CACrB,IAAI,EACJ,YAAwC,EACxC,OAAO,CAKP,CAAC;IACH,CAAC;IAqFD;;;;;OAKG;IACI,MAAM,CACZ,kBAA8E,EAC9E,iBAAqB;QASrB,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,KAAK,GAAG,kBAAsE,CAAC;YACrF,MAAM,QAAQ,GAAG,IAAA,iCAAc,EAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACjD,OAAO,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,CACnD,IAAI,CAAC,WAAW,CACf,QAAQ,EACR,kBAAuB;YACvB,kBAAkB,CAAC,KAAK;YACxB,6BAA6B,CAAC,IAAI,CAClC,CASD,CAAC;QACH,CAAC;QACD,MAAM,GAAG,GAQL,IAAI,CAAC,WAAW,CACnB,kBAA2B,EAC3B,iBAAiB;QACjB,kBAAkB,CAAC,IAAI;QACvB,6BAA6B,CAAC,IAAI,CAClC,CAAC;QACF,OAAO,GAAG,CAAC;IACZ,CAAC;IAED;;;;;;;OAOG;IACK,WAAW,CAMlB,IAAU,EACV,YAAe,EACf,YAAqB,EACrB,uBAAgD,EAChD,OAAiD;QAWjD,MAAM,MAAM,GAAG,IAAA,uBAAY,EAAC;YAC3B,UAAU,EAAE,IAAA,yBAAM,EAAsB,IAAI,EAAE,IAAI,CAAC;YACnD,IAAI,EAAE,YAAY;YAClB,YAAY;YACZ,uBAAuB;YACvB,QAAQ,EAAE,OAAO,EAAE,QAAQ;YAC3B,iBAAiB,EAAE,OAAO,EAAE,iBAAiB;SAC7C,CAAC,CAAC;QAEH,OAAO,MASN,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACI,WAAW,CAKjB,IAAU,EACV,YAAe,EACf,OAAiD;QAEjD,OAAO,IAAA,uBAAY,EAAC;YACnB,UAAU,EAAE,IAAA,yBAAM,EAAsB,IAAI,EAAE,IAAI,CAAC;YACnD,IAAI,EAAE,YAAY;YAClB,YAAY,EAAE,IAAI;YAClB,uBAAuB,EAAE,IAAI;YAC7B,QAAQ,EAAE,OAAO,EAAE,QAAQ;YAC3B,iBAAiB,EAAE,OAAO,EAAE,iBAAiB;SAC7C,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,4EAA4E;IACrE,eAAe,CAIpB,IAAU,EAAE,YAAe,EAAE,OAAiD;QAC/E,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CACpC,IAAI,EACJ,YAAwC;QACxC,kBAAkB,CAAC,IAAI;QACvB,iFAAiF;QACjF,8GAA8G;QAC9G,6BAA6B,CAAC,KAAK,EACnC,OAAO,CACP,CAAC;QAEF,OAAO,YAgBN,CAAC;IACH,CAAC;IAED;;OAEG;IACI,kBAAkB,CAGvB,IAAO;QACR,OAAO,IAAI,kBAAkB,CAAC,IAAA,yBAAM,EAAmB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACrE,CAAC;;AAxhBF,gDAyhBC;AAtbA;;GAEG;AAC6B,yBAAM,GAAG,gCAAa,CAAC,MAAM,AAAvB,CAAwB;AAE9D;;GAEG;AAC6B,2BAAQ,GAAG,gCAAa,CAAC,QAAQ,AAAzB,CAA0B;AAElE;;GAEG;AAC6B,2BAAQ,GAAG,gCAAa,CAAC,QAAQ,AAAzB,CAA0B;AAElE;;GAEG;AAC6B,oCAAiB,GAAG,gCAAa,CAAC,iBAAiB,AAAlC,CAAmC;AAEpF;;GAEG;AAC6B,oCAAiB,GAAG,gCAAa,CAAC,iBAAiB,AAAlC,CAAmC;AAEpF;;GAEG;AACoB,6BAAU,GAAG,gCAAa,CAAC,UAAU,AAA3B,CAA4B;AA2B7D;;GAEG;AACW,yBAAM,GAAG,kBAAkB,CAAC,MAAM,AAA5B,CAA6B","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport {\n\ttype ArrayNodeCustomizableSchema,\n\tarraySchema,\n\ttype MapNodeCustomizableSchema,\n\tmapSchema,\n\ttype ObjectNodeSchema,\n\tobjectSchema,\n\ttype RecordNodeCustomizableSchema,\n\ttype RecordNodeInsertableData,\n\trecordSchema,\n\ttype TreeRecordNode,\n} from \"../node-kinds/index.js\";\nimport {\n\tdefaultSchemaFactoryObjectOptions,\n\tscoped,\n\tstructuralName,\n\ttype NodeSchemaOptionsAlpha,\n\ttype SchemaFactoryObjectOptions,\n\ttype ScopedSchemaName,\n} from \"./schemaFactory.js\";\nimport { schemaStatics } from \"./schemaStatics.js\";\nimport type { ImplicitAnnotatedFieldSchema, ImplicitFieldSchema } from \"../fieldSchema.js\";\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\nimport type {\n\tNodeKind,\n\tTreeNodeSchema,\n\tTreeNodeSchemaBoth,\n\tTreeNodeSchemaClass,\n\tTreeNodeSchemaNonClass,\n\tWithType,\n\tImplicitAllowedTypes,\n\tImplicitAnnotatedAllowedTypes,\n\tAnnotatedAllowedType,\n\tLazyItem,\n} from \"../core/index.js\";\nimport { normalizeToAnnotatedAllowedType, createSchemaUpgrade } from \"../core/index.js\";\nimport type {\n\tArrayNodeCustomizableSchemaUnsafe,\n\tMapNodeCustomizableSchemaUnsafe,\n\tSystem_Unsafe,\n\tTreeRecordNodeUnsafe,\n} from \"./typesUnsafe.js\";\nimport type { SimpleObjectNodeSchema } from \"../simpleSchema.js\";\nimport { SchemaFactoryBeta } from \"./schemaFactoryBeta.js\";\n\n// This import prevents a large number of type references in the API reports from showing up as _2.\n/* eslint-disable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates /\nimport type {\n\tFieldProps,\n\tFieldSchemaAlpha,\n\tFieldPropsAlpha,\n\tFieldKind,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema } from \"../leafNodeSchema.js\";\nimport type { SimpleLeafNodeSchema } from \"../simpleSchema.js\";\nimport type { UnannotateImplicitAllowedTypes } from \"../core/index.js\";\nimport type { FieldSchemaAlphaUnsafe } from \"./typesUnsafe.js\";\n/ eslint-enable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates /\n\n/\n Stateless APIs exposed via {@link SchemaFactoryAlpha} as both instance properties and as statics.\n * @remarks\n * See {@link SchemaStatics} for why this is useful.\n * @system @sealed @alpha\n /\nexport interface SchemaStaticsAlpha {\n\t/\n\t Declares a staged type in a set of {@link AllowedTypes}.\n\t \n\t @remarks\n\t * Staged allowed types add support for loading documents which may or may not permit an allowed type in a location in a schema.\n\t * This allows for an incremental rollout of a schema change to add a {@link TreeNodeSchema} to an {@link AllowedTypes} without breaking cross version collaboration.\n\t \n\t Once enough clients have the type staged (and thus can read documents which allow it), documents can start being created and upgraded to allow the staged type.\n\t * This is done by deploying a new version of the app which removes the `staged` wrapper around the allowed type in the the schema definition.\n\t * This will also require {@link TreeView.upgradeSchema\|upgrading the schema} for existing documents.\n\t \n\t Using a staged allowed type in a schema is just like using the schema as an allowed type with the following exceptions:\n\t \n\t 1. {@link TreeView.initialize} will omit the staged allowed type from the newly created stored schema.\n\t * 2. {@link TreeView.upgradeSchema} will omit the staged allowed type from the the upgraded stored schema.\n\t * 3. When evaluating {@link TreeView.compatibility}, it will be viewable even if the staged allowed type is not present in the stored schema's corresponding allowed types.\n\t * 4. Because of the above, it is possible to get errors when inserting content which uses the staged allowed type when inserting the content into a tree who's stored schema does not permit it.\n\t \n\t Currently, `staged` is not supported in the recursive type APIs: this is a known limitation which future versions of the API will address.\n\t \n\t @example\n\t * Suppose you have a schema which has a field that allows some type `A`, but you want to add support for type `B`.\n\t \n\t The first change is to used to mark the new type as staged, replacing `A` in the schema with `[A, SchemaStaticsAlpha.staged(B)]`.\n\t * Once this is done, and any code which reads contents from documents is updated to handle any `B` content that may be present, this version of the code can be deployed.\n\t \n\t Once all users have the above changes, the schema can be updated again to `[A, B]`, and the app can be updated to allow creating of `B` content.\n\t * This updated version of the app will need to call {@link TreeView.upgradeSchema} when opening documents created by earlier versions.\n\t \n\t Adding a `B` schema as an option in the root could look like this:\n\t * ```typescript\n\t * const factory = new SchemaFactoryAlpha(\"test\");\n\t * class A extends factory.objectAlpha(\"A\", {}) {}\n\t * class B extends factory.objectAlpha(\"B\", {}) {}\n\t \n\t // Does not support B\n\t * const configBefore = new TreeViewConfigurationAlpha({\n\t * \tschema: A,\n\t * });\n\t \n\t // Supports documents with or without B\n\t * const configStaged = new TreeViewConfigurationAlpha({\n\t * \t// Adds staged support for B.\n\t * \t// Currently this requires wrapping the root field with `SchemaFactoryAlpha.required`:\n\t * \t// this is normally implicitly included, but is currently required while the \"staged\" APIs are `@alpha`.\n\t * \tschema: SchemaFactoryAlpha.required([A, SchemaFactoryAlpha.staged(B)]),\n\t * });\n\t \n\t // Only supports documents with A and B: can be used to upgrade schema to add B.\n\t * const configAfter = new TreeViewConfigurationAlpha({\n\t * \tschema: [A, B],\n\t * });\n\t * ```\n\t * @example\n\t * Below is a full example of how the schema migration process works.\n\t * This can also be found in our {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts \| tests}.\n\t * ```typescript\n\t * // Schema A: only number allowed\n\t * const schemaA = SchemaFactoryAlpha.optional([SchemaFactoryAlpha.number]);\n\t \n\t // Schema B: number or string (string is staged)\n\t * const schemaB = SchemaFactoryAlpha.optional([\n\t * \tSchemaFactoryAlpha.number,\n\t * \tSchemaFactoryAlpha.staged(SchemaFactoryAlpha.string),\n\t * ]);\n\t \n\t // Schema C: number or string, both fully allowed\n\t * const schemaC = SchemaFactoryAlpha.optional([\n\t * \tSchemaFactoryAlpha.number,\n\t * \tSchemaFactoryAlpha.string,\n\t * ]);\n\t \n\t // Initialize with schema A.\n\t * const configA = new TreeViewConfiguration({\n\t * \tschema: schemaA,\n\t * });\n\t * const viewA = treeA.viewWith(configA);\n\t * viewA.initialize(5);\n\t \n\t // Since we are running all the different versions of the app in the same process making changes synchronously,\n\t * // an explicit flush is needed to make them available to each other.\n\t * synchronizeTrees();\n\t \n\t assert.deepEqual(viewA.root, 5);\n\t \n\t // View the same document with a second tree using schema B.\n\t * const configB = new TreeViewConfiguration({\n\t * \tschema: schemaB,\n\t * });\n\t * const viewB = treeB.viewWith(configB);\n\t * // B cannot write strings to the root.\n\t * assert.throws(() => (viewB.root = \"test\"));\n\t \n\t // View the same document with a third tree using schema C.\n\t * const configC = new TreeViewConfiguration({\n\t * \tschema: schemaC,\n\t * });\n\t * const viewC = treeC.viewWith(configC);\n\t * // Upgrade to schema C\n\t * viewC.upgradeSchema();\n\t * // Use the newly enabled schema.\n\t * viewC.root = \"test\";\n\t \n\t synchronizeTrees();\n\t \n\t // View A is now incompatible with the stored schema:\n\t * assert.equal(viewA.compatibility.canView, false);\n\t \n\t // View B can still read the document, and now sees the string root which relies on the staged schema.\n\t * assert.deepEqual(viewB.root, \"test\");\n\t * ```\n\t * @privateRemarks\n\t * TODO:#44317 staged allowed types rely on schema validation of stored schema to output errors, these errors are not very\n\t * user friendly and should be improved, particularly in the case of staged allowed types\n\t \n\t TODO: the example above does not work tell in intellisense: its formatted to work onm the website. We should find a solution that works well for both.\n\t \n\t TODO: AB#45711: Update the docs above when recursive type support is added.\n\t /\n\tstaged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t) => AnnotatedAllowedType<T>;\n}\n\nconst schemaStaticsAlpha: SchemaStaticsAlpha = {\n\tstaged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t): AnnotatedAllowedType<T> => {\n\t\tconst annotatedType = normalizeToAnnotatedAllowedType(t);\n\t\treturn {\n\t\t\ttype: annotatedType.type,\n\t\t\tmetadata: {\n\t\t\t\t...annotatedType.metadata,\n\t\t\t\tstagedSchemaUpgrade: createSchemaUpgrade(),\n\t\t\t},\n\t\t};\n\t},\n};\n\n/\n {@link SchemaFactory} with additional alpha APIs.\n \n @alpha\n * @privateRemarks\n * When building schema, when `options` is not provided, `TCustomMetadata` is inferred as `unknown`.\n * If desired, this could be made to infer `undefined` instead by adding overloads for everything,\n * but currently it is not worth the maintenance overhead as there is no use case which this is known to be helpful for.\n /\nexport class SchemaFactoryAlpha<\n\tout TScope extends string \| undefined = string \| undefined,\n\tTName extends number \| string = string,\n> extends SchemaFactoryBeta<TScope, TName> {\n\t/\n\t Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.\n\t * @param options - Additional options for the schema.\n\t /\n\tpublic objectAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: SchemaFactoryObjectOptions<TCustomMetadata>,\n\t): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> & {\n\t\t/\n\t\t Typing checking workaround: not for for actual use.\n\t\t * @remarks\n\t\t * This API collides with {@link TreeNodeSchemaCore.createFromInsertable} to disable a type checking optimization which produces different and undesired results.\n\t\t * See {@link https://github.com/microsoft/TypeScript/issues/59049#issuecomment-2773459693} for more details.\n\t\t * @privateRemarks\n\t\t * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,\n\t\t * See the above link and the tests in objectNode.spec.ts which reference it.\n\t\t * @system\n\t\t /\n\t\treadonly createFromInsertable: unknown;\n\t} {\n\t\treturn objectSchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tfields,\n\t\t\ttrue,\n\t\t\toptions?.allowUnknownOptionalFields ??\n\t\t\t\tdefaultSchemaFactoryObjectOptions.allowUnknownOptionalFields,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritdoc SchemaFactory.objectRecursive}\n\t /\n\tpublic override objectRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tt: T,\n\t\toptions?: SchemaFactoryObjectOptions<TCustomMetadata>,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Object,\n\t\tSystem_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>,\n\t\tobject & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\tfalse,\n\t\tT,\n\t\tnever,\n\t\tTCustomMetadata\n\t> &\n\t\tSimpleObjectNodeSchema<TCustomMetadata> &\n\t\t// We can't just use non generic `ObjectNodeSchema` here since \"Base constructors must all have the same return type\".\n\t\t// We also can't just use generic `ObjectNodeSchema` here and not `TreeNodeSchemaClass` since that doesn't work with unsafe recursive types.\n\t\t// ObjectNodeSchema<\n\t\t// \tScopedSchemaName<TScope, Name>,\n\t\t// \t// T & RestrictiveStringRecord<ImplicitFieldSchema> would be nice to use here, but it breaks the recursive type self references.\n\t\t// \tRestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t// \tfalse,\n\t\t// \tTCustomMetadata\n\t\t// >\n\t\tPick<ObjectNodeSchema, \"fields\"> {\n\t\t// TODO: syntax highting is vs code is broken here. Don't trust it. Use the compiler instead.\n\t\ttype TScopedName = ScopedSchemaName<TScope, Name>;\n\t\treturn this.objectAlpha(\n\t\t\tname,\n\t\t\tt as T & RestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t\toptions,\n\t\t) as unknown as TreeNodeSchemaClass<\n\t\t\tTScopedName,\n\t\t\tNodeKind.Object,\n\t\t\tSystem_Unsafe.TreeObjectNodeUnsafe<T, TScopedName>,\n\t\t\tobject & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\t\tfalse,\n\t\t\tT,\n\t\t\tnever,\n\t\t\tTCustomMetadata\n\t\t> &\n\t\t\tObjectNodeSchema<\n\t\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\t\tRestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t\t\tfalse,\n\t\t\t\tTCustomMetadata\n\t\t\t>;\n\t}\n\n\t/\n\t {@inheritDoc SchemaStatics.leaves}\n\t /\n\tpublic static override readonly leaves = schemaStatics.leaves;\n\n\t/\n\t {@inheritDoc SchemaStatics.optional}\n\t /\n\tpublic static override readonly optional = schemaStatics.optional;\n\n\t/\n\t {@inheritDoc SchemaStatics.required}\n\t /\n\tpublic static override readonly required = schemaStatics.required;\n\n\t/\n\t {@inheritDoc SchemaStatics.optionalRecursive}\n\t /\n\tpublic static override readonly optionalRecursive = schemaStatics.optionalRecursive;\n\n\t/\n\t {@inheritDoc SchemaStatics.requiredRecursive}\n\t /\n\tpublic static override readonly requiredRecursive = schemaStatics.requiredRecursive;\n\n\t/\n\t Like {@link SchemaFactory.identifier} but static and a factory function that can be provided {@link FieldProps}.\n\t /\n\tpublic static readonly identifier = schemaStatics.identifier;\n\n\t/\n\t {@inheritDoc SchemaStatics.leaves}\n\t /\n\tpublic override readonly leaves = schemaStatics.leaves;\n\n\t/\n\t {@inheritDoc SchemaStatics.optional}\n\t /\n\tpublic override readonly optional = schemaStatics.optional;\n\n\t/\n\t {@inheritDoc SchemaStatics.required}\n\t /\n\tpublic override readonly required = schemaStatics.required;\n\n\t/\n\t {@inheritDoc SchemaStatics.optionalRecursive}\n\t /\n\tpublic override readonly optionalRecursive = schemaStatics.optionalRecursive;\n\n\t/\n\t {@inheritDoc SchemaStatics.requiredRecursive}\n\t /\n\tpublic override readonly requiredRecursive = schemaStatics.requiredRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsAlpha.staged}\n\t /\n\tpublic static staged = schemaStaticsAlpha.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsAlpha.staged}\n\t /\n\tpublic staged = schemaStaticsAlpha.staged;\n\n\t/\n\t Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear as values in the map.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedMap extends factory.map(\"name\", factory.number, {\n\t * \tmetadata: { description: \"A map of numbers\" }\n\t * }) {}\n\t * ```\n\t /\n\tpublic mapAlpha<\n\t\tName extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): MapNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn mapSchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tallowedTypes,\n\t\t\ttrue,\n\t\t\ttrue,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactory.objectRecursive}\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override mapRecursive<\n\t\tName extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\treturn this.mapAlpha(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\toptions,\n\t\t) as unknown as MapNodeCustomizableSchemaUnsafe<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tT,\n\t\t\tTCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t Define a {@link TreeNodeSchemaClass} for a {@link (TreeArrayNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear in the array.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedArray extends factory.arrayAlpha(\"name\", factory.number) {}\n\t * ```\n\t /\n\tpublic arrayAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): ArrayNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn arraySchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tallowedTypes,\n\t\t\ttrue,\n\t\t\ttrue,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactory.objectRecursive}\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override arrayRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\treturn this.arrayAlpha(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\toptions,\n\t\t) as unknown as ArrayNodeCustomizableSchemaUnsafe<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tT,\n\t\t\tTCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.\n\t \n\t @param allowedTypes - The types that may appear in the record.\n\t \n\t @remarks\n\t * The identifier for this record is defined as a function of the provided types.\n\t * It is still scoped to this `SchemaFactory`, but multiple calls with the same arguments will return the same\n\t * schema object, providing somewhat structural typing.\n\t * This does not support recursive types.\n\t \n\t If using these structurally named records, other types in this schema builder should avoid names of the form `Record<${string}>`.\n\t \n\t @example\n\t * The returned schema should be used as a schema directly:\n\t * ```typescript\n\t * const MyRecord = factory.record(factory.number);\n\t * type MyRecord = NodeFromSchema<typeof Record>;\n\t * ```\n\t * Or inline:\n\t * ```typescript\n\t * factory.object(\"Foo\", { myRecord: factory.record(factory.number) });\n\t * ```\n\t \n\t @privateRemarks\n\t * The name produced at the type-level here is not as specific as it could be; however, doing type-level sorting and escaping is a real mess.\n\t * There are cases where not having this full type provided will be less than ideal, since TypeScript's structural types will allow assignment between runtime incompatible types at compile time.\n\t * For example, attempts to narrow unions of structural records by name won't work.\n\t * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,\n\t * though there may still be some problematic cases even after that work is done.\n\t \n\t The return value is a class, but its type is intentionally not specific enough to indicate it is a class.\n\t * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls to this different subclasses)\n\t * when working with structural typing.\n\t \n\t {@label STRUCTURAL}\n\t /\n\tpublic record<const T extends TreeNodeSchema \| readonly TreeNodeSchema[]>(\n\t\tallowedTypes: T,\n\t): TreeNodeSchemaNonClass<\n\t\t/ Name / ScopedSchemaName<TScope, `Record<${string}>`>,\n\t\t/ Kind / NodeKind.Record,\n\t\t/ TNode / TreeRecordNode<T> &\n\t\t\tWithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>,\n\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t/ ImplicitlyConstructable / true,\n\t\t/ Info / T,\n\t\t/ TConstructorExtra / undefined\n\t>;\n\t/\n\t Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear in the record.\n\t \n\t @remarks\n\t * Like TypeScript `Record`s, record nodes have some potential pitfalls.\n\t * For example: TypeScript makes assumptions about built-in keys being present (e.g. `toString`, `hasOwnProperty`, etc.).\n\t * Since these are otherwise valid keys in a record, this can lead to unexpected behavior.\n\t * To prevent inconsistent behavior, these built-ins are hidden by record nodes.\n\t * This means that if you try to call these built-ins (e.g. `toString()`) on a record node, you will get an error.\n\t \n\t In most cases, it is probably preferable to use {@link SchemaFactory.(map:2)} instead.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedRecord extends factory.record(\"name\", factory.number) {}\n\t * ```\n\t \n\t {@label NAMED}\n\t /\n\tpublic record<const Name extends TName, const T extends ImplicitAllowedTypes>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t): TreeNodeSchemaClass<\n\t\t/ Name / ScopedSchemaName<TScope, Name>,\n\t\t/ Kind / NodeKind.Record,\n\t\t/ TNode / TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>,\n\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t/ ImplicitlyConstructable / true,\n\t\t/ Info / T,\n\t\t/ TConstructorExtra / undefined\n\t>;\n\t/\n\t {@link SchemaFactory.array} implementation.\n\t \n\t @privateRemarks\n\t * This should return TreeNodeSchemaBoth: see note on \"map\" implementation for details.\n\t /\n\tpublic record<const T extends ImplicitAllowedTypes>(\n\t\tnameOrAllowedTypes: TName \| ((T & TreeNodeSchema) \| readonly TreeNodeSchema[]),\n\t\tmaybeAllowedTypes?: T,\n\t): TreeNodeSchema<\n\t\t/ Name / ScopedSchemaName<TScope, string>,\n\t\t/ Kind / NodeKind.Record,\n\t\t/ TNode / TreeRecordNode<T>,\n\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t/ ImplicitlyConstructable / true,\n\t\t/ Info / T\n\t> {\n\t\tif (maybeAllowedTypes === undefined) {\n\t\t\tconst types = nameOrAllowedTypes as (T & TreeNodeSchema) \| readonly TreeNodeSchema[];\n\t\t\tconst fullName = structuralName(\"Record\", types);\n\t\t\treturn this.getStructuralType(fullName, types, () =>\n\t\t\t\tthis.namedRecord(\n\t\t\t\t\tfullName,\n\t\t\t\t\tnameOrAllowedTypes as T,\n\t\t\t\t\t/ customizable / false,\n\t\t\t\t\t/ implicitlyConstructable / true,\n\t\t\t\t),\n\t\t\t) as TreeNodeSchemaClass<\n\t\t\t\t/ Name / ScopedSchemaName<TScope, string>,\n\t\t\t\t/ Kind / NodeKind.Record,\n\t\t\t\t/ TNode / TreeRecordNode<T>,\n\t\t\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t\t\t/ ImplicitlyConstructable / true,\n\t\t\t\t/ Info / T,\n\t\t\t\t/ TConstructorExtra / undefined\n\t\t\t>;\n\t\t}\n\t\tconst out: TreeNodeSchemaBoth<\n\t\t\t/ Name / ScopedSchemaName<TScope, string>,\n\t\t\t/ Kind / NodeKind.Record,\n\t\t\t/ TNode / TreeRecordNode<T>,\n\t\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t\t/ ImplicitlyConstructable / true,\n\t\t\t/ Info / T,\n\t\t\t/ TConstructorExtra / undefined\n\t\t> = this.namedRecord(\n\t\t\tnameOrAllowedTypes as TName,\n\t\t\tmaybeAllowedTypes,\n\t\t\t/ customizable / true,\n\t\t\t/ implicitlyConstructable / true,\n\t\t);\n\t\treturn out;\n\t}\n\n\t/\n\t Define a {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t \n\t @remarks\n\t * This is not intended to be used directly, use the overload of `record` which takes a name instead.\n\t /\n\tprivate namedRecord<\n\t\tName extends TName \| string,\n\t\tconst T extends ImplicitAllowedTypes,\n\t\tconst ImplicitlyConstructable extends boolean,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\tcustomizable: boolean,\n\t\timplicitlyConstructable: ImplicitlyConstructable,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): TreeNodeSchemaBoth<\n\t\t/ Name / ScopedSchemaName<TScope, Name>,\n\t\t/ Kind / NodeKind.Record,\n\t\t/ TNode / TreeRecordNode<T> &\n\t\t\tWithType<ScopedSchemaName<TScope, string>, NodeKind.Record>,\n\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t/ ImplicitlyConstructable / ImplicitlyConstructable,\n\t\t/ Info / T,\n\t\t/ TConstructorExtra / undefined\n\t> {\n\t\tconst record = recordSchema({\n\t\t\tidentifier: scoped<TScope, TName, Name>(this, name),\n\t\t\tinfo: allowedTypes,\n\t\t\tcustomizable,\n\t\t\timplicitlyConstructable,\n\t\t\tmetadata: options?.metadata,\n\t\t\tpersistedMetadata: options?.persistedMetadata,\n\t\t});\n\n\t\treturn record as TreeNodeSchemaBoth<\n\t\t\t/ Name / ScopedSchemaName<TScope, Name>,\n\t\t\t/ Kind / NodeKind.Record,\n\t\t\t/ TNode / TreeRecordNode<T> &\n\t\t\t\tWithType<ScopedSchemaName<TScope, string>, NodeKind.Record>,\n\t\t\t/ TInsertable / RecordNodeInsertableData<T>,\n\t\t\t/ ImplicitlyConstructable / ImplicitlyConstructable,\n\t\t\t/ Info / T,\n\t\t\t/ TConstructorExtra / undefined\n\t\t>;\n\t}\n\n\t/\n\t Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear in the record.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedRecord extends factory.recordAlpha(\"name\", factory.number) {}\n\t * ```\n\t /\n\tpublic recordAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn recordSchema({\n\t\t\tidentifier: scoped<TScope, TName, Name>(this, name),\n\t\t\tinfo: allowedTypes,\n\t\t\tcustomizable: true,\n\t\t\timplicitlyConstructable: true,\n\t\t\tmetadata: options?.metadata,\n\t\t\tpersistedMetadata: options?.persistedMetadata,\n\t\t});\n\t}\n\n\t/\n\t {@link SchemaFactoryAlpha.(record:2)} except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic recordRecursive<\n\t\tName extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\tconst RecordSchema = this.namedRecord(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\t/ customizable / true,\n\t\t\t// Setting this to true seems to work ok currently, but not for other node kinds.\n\t\t\t// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.\n\t\t\t/ implicitlyConstructable / false,\n\t\t\toptions,\n\t\t);\n\n\t\treturn RecordSchema as TreeNodeSchemaClass<\n\t\t\t/ Name / ScopedSchemaName<TScope, Name>,\n\t\t\t/ Kind / NodeKind.Record,\n\t\t\t/ TNode / TreeRecordNodeUnsafe<T> &\n\t\t\t\tWithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>,\n\t\t\t/ TInsertable / {\n\t\t\t\t// Ideally this would be\n\t\t\t\t// RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,\n\t\t\t\t// but doing so breaks recursive types.\n\t\t\t\t// Instead we do a less nice version:\n\t\t\t\treadonly [P in string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;\n\t\t\t},\n\t\t\t/ ImplicitlyConstructable / false,\n\t\t\t/ Info / T,\n\t\t\t/ TConstructorExtra / undefined,\n\t\t\t/ TCustomMetadata / TCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactoryBeta.scopedFactory}\n\t */\n\tpublic scopedFactoryAlpha<\n\t\tconst T extends TName,\n\t\tTNameInner extends number \| string = string,\n\t>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner> {\n\t\treturn new SchemaFactoryAlpha(scoped<TScope, TName, T>(this, name));\n\t}\n}\n"]}
1	+ {"version":3,"file":"schemaFactoryAlpha.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryAlpha.ts"],"names":[],"mappings":"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","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport {\n\ttype ArrayNodeCustomizableSchema,\n\tarraySchema,\n\ttype MapNodeCustomizableSchema,\n\tmapSchema,\n\ttype ObjectNodeSchema,\n\tobjectSchema,\n\ttype RecordNodeCustomizableSchema,\n\trecordSchema,\n} from \"../node-kinds/index.js\";\nimport {\n\tdefaultSchemaFactoryObjectOptions,\n\tscoped,\n\ttype NodeSchemaOptionsAlpha,\n\ttype SchemaFactoryObjectOptions,\n\ttype ScopedSchemaName,\n} from \"./schemaFactory.js\";\nimport { schemaStatics } from \"./schemaStatics.js\";\nimport type { ImplicitAnnotatedFieldSchema, ImplicitFieldSchema } from \"../fieldSchema.js\";\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\nimport type {\n\tNodeKind,\n\tTreeNodeSchema,\n\tTreeNodeSchemaClass,\n\tImplicitAllowedTypes,\n\tImplicitAnnotatedAllowedTypes,\n\tAnnotatedAllowedType,\n\tLazyItem,\n\tWithType,\n} from \"../core/index.js\";\nimport { normalizeToAnnotatedAllowedType, createSchemaUpgrade } from \"../core/index.js\";\nimport type {\n\tArrayNodeCustomizableSchemaUnsafe,\n\tMapNodeCustomizableSchemaUnsafe,\n\tSystem_Unsafe,\n\tTreeRecordNodeUnsafe,\n} from \"./typesUnsafe.js\";\nimport type { SimpleObjectNodeSchema } from \"../simpleSchema.js\";\nimport { SchemaFactoryBeta } from \"./schemaFactoryBeta.js\";\n\n// These imports prevent a large number of type references in the API reports from showing up as _2.\n/* eslint-disable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates /\nimport type {\n\tFieldProps,\n\tFieldSchemaAlpha,\n\tFieldPropsAlpha,\n\tFieldKind,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema } from \"../leafNodeSchema.js\";\nimport type { SimpleLeafNodeSchema } from \"../simpleSchema.js\";\nimport type { UnannotateImplicitAllowedTypes } from \"../core/index.js\";\nimport type { FieldSchemaAlphaUnsafe } from \"./typesUnsafe.js\";\n/ eslint-enable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import/no-duplicates /\n\n/\n Stateless APIs exposed via {@link SchemaFactoryAlpha} as both instance properties and as statics.\n * @remarks\n * See {@link SchemaStatics} for why this is useful.\n * @system @sealed @alpha\n /\nexport interface SchemaStaticsAlpha {\n\t/\n\t Declares a staged type in a set of {@link AllowedTypes}.\n\t \n\t @remarks\n\t * Staged allowed types add support for loading documents which may contain that type at the declared location.\n\t * This allows for an incremental rollout of a schema change to add a {@link TreeNodeSchema} to an {@link AllowedTypes} without breaking cross version collaboration.\n\t * A guide on this process can be found here: https://fluidframework.com/docs/data-structures/tree/schema-evolution/allowed-types-rollout\n\t \n\t Once enough clients have the type staged (and thus can read documents which allow it), documents can start being created and upgraded to allow the staged type.\n\t * This is done by deploying a new version of the app which removes the `staged` wrapper around the allowed type in the the schema definition.\n\t * This will also require {@link TreeView.upgradeSchema\|upgrading the schema} for existing documents.\n\t \n\t Using a staged allowed type in a schema is just like using the schema as an allowed type with the following exceptions:\n\t \n\t 1. {@link TreeView.initialize} will omit the staged allowed type from the newly created stored schema.\n\t * 2. {@link TreeView.upgradeSchema} will omit the staged allowed type from the the upgraded stored schema.\n\t * 3. When evaluating {@link TreeView.compatibility}, it will be viewable even if the staged allowed type is not present in the stored schema's corresponding allowed types.\n\t * 4. Because of the above, it is possible to get errors when inserting content which uses the staged allowed type into a tree whose stored schema does not permit it.\n\t \n\t Currently, `staged` is not supported in the recursive type APIs: this is a known limitation which future versions of the API will address.\n\t \n\t @example\n\t * A full code example of the schema migration process can be found in our {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts \| tests}.\n\t \n\t @privateRemarks\n\t * TODO:#44317 staged allowed types rely on schema validation of stored schema to output errors, these errors are not very\n\t * user friendly and should be improved, particularly in the case of staged allowed types\n\t \n\t TODO: AB#45711: Update the docs above when recursive type support is added.\n\t /\n\tstaged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t) => AnnotatedAllowedType<T>;\n}\n\nconst schemaStaticsAlpha: SchemaStaticsAlpha = {\n\tstaged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t): AnnotatedAllowedType<T> => {\n\t\tconst annotatedType = normalizeToAnnotatedAllowedType(t);\n\t\treturn {\n\t\t\ttype: annotatedType.type,\n\t\t\tmetadata: {\n\t\t\t\t...annotatedType.metadata,\n\t\t\t\tstagedSchemaUpgrade: createSchemaUpgrade(),\n\t\t\t},\n\t\t};\n\t},\n};\n\n/\n {@link SchemaFactory} with additional alpha APIs.\n \n @alpha\n * @privateRemarks\n * When building schema, when `options` is not provided, `TCustomMetadata` is inferred as `unknown`.\n * If desired, this could be made to infer `undefined` instead by adding overloads for everything,\n * but currently it is not worth the maintenance overhead as there is no use case which this is known to be helpful for.\n /\nexport class SchemaFactoryAlpha<\n\tout TScope extends string \| undefined = string \| undefined,\n\tTName extends number \| string = string,\n> extends SchemaFactoryBeta<TScope, TName> {\n\t/\n\t Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.\n\t * @param options - Additional options for the schema.\n\t /\n\tpublic objectAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: SchemaFactoryObjectOptions<TCustomMetadata>,\n\t): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> & {\n\t\t/\n\t\t Typing checking workaround: not for for actual use.\n\t\t * @remarks\n\t\t * This API collides with {@link TreeNodeSchemaCore.createFromInsertable} to disable a type checking optimization which produces different and undesired results.\n\t\t * See {@link https://github.com/microsoft/TypeScript/issues/59049#issuecomment-2773459693} for more details.\n\t\t * @privateRemarks\n\t\t * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,\n\t\t * See the above link and the tests in objectNode.spec.ts which reference it.\n\t\t * @system\n\t\t /\n\t\treadonly createFromInsertable: unknown;\n\t} {\n\t\treturn objectSchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tfields,\n\t\t\ttrue,\n\t\t\toptions?.allowUnknownOptionalFields ??\n\t\t\t\tdefaultSchemaFactoryObjectOptions.allowUnknownOptionalFields,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritdoc SchemaFactory.objectRecursive}\n\t /\n\tpublic override objectRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tt: T,\n\t\toptions?: SchemaFactoryObjectOptions<TCustomMetadata>,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Object,\n\t\tSystem_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>,\n\t\tobject & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\tfalse,\n\t\tT,\n\t\tnever,\n\t\tTCustomMetadata\n\t> &\n\t\tSimpleObjectNodeSchema<TCustomMetadata> &\n\t\t// We can't just use non generic `ObjectNodeSchema` here since \"Base constructors must all have the same return type\".\n\t\t// We also can't just use generic `ObjectNodeSchema` here and not `TreeNodeSchemaClass` since that doesn't work with unsafe recursive types.\n\t\t// ObjectNodeSchema<\n\t\t// \tScopedSchemaName<TScope, Name>,\n\t\t// \t// T & RestrictiveStringRecord<ImplicitFieldSchema> would be nice to use here, but it breaks the recursive type self references.\n\t\t// \tRestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t// \tfalse,\n\t\t// \tTCustomMetadata\n\t\t// >\n\t\tPick<ObjectNodeSchema, \"fields\"> {\n\t\t// TODO: syntax highting is vs code is broken here. Don't trust it. Use the compiler instead.\n\t\ttype TScopedName = ScopedSchemaName<TScope, Name>;\n\t\treturn this.objectAlpha(\n\t\t\tname,\n\t\t\tt as T & RestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t\toptions,\n\t\t) as unknown as TreeNodeSchemaClass<\n\t\t\tTScopedName,\n\t\t\tNodeKind.Object,\n\t\t\tSystem_Unsafe.TreeObjectNodeUnsafe<T, TScopedName>,\n\t\t\tobject & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\t\tfalse,\n\t\t\tT,\n\t\t\tnever,\n\t\t\tTCustomMetadata\n\t\t> &\n\t\t\tObjectNodeSchema<\n\t\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\t\tRestrictiveStringRecord<ImplicitFieldSchema>,\n\t\t\t\tfalse,\n\t\t\t\tTCustomMetadata\n\t\t\t>;\n\t}\n\n\t/\n\t {@inheritDoc SchemaStatics.leaves}\n\t /\n\tpublic static override readonly leaves = schemaStatics.leaves;\n\n\t/\n\t {@inheritDoc SchemaStatics.optional}\n\t /\n\tpublic static override readonly optional = schemaStatics.optional;\n\n\t/\n\t {@inheritDoc SchemaStatics.required}\n\t /\n\tpublic static override readonly required = schemaStatics.required;\n\n\t/\n\t {@inheritDoc SchemaStatics.optionalRecursive}\n\t /\n\tpublic static override readonly optionalRecursive = schemaStatics.optionalRecursive;\n\n\t/\n\t {@inheritDoc SchemaStatics.requiredRecursive}\n\t /\n\tpublic static override readonly requiredRecursive = schemaStatics.requiredRecursive;\n\n\t/\n\t Like {@link SchemaFactory.identifier} but static and a factory function that can be provided {@link FieldProps}.\n\t /\n\tpublic static readonly identifier = schemaStatics.identifier;\n\n\t/\n\t {@inheritDoc SchemaStatics.leaves}\n\t /\n\tpublic override readonly leaves = schemaStatics.leaves;\n\n\t/\n\t {@inheritDoc SchemaStatics.optional}\n\t /\n\tpublic override readonly optional = schemaStatics.optional;\n\n\t/\n\t {@inheritDoc SchemaStatics.required}\n\t /\n\tpublic override readonly required = schemaStatics.required;\n\n\t/\n\t {@inheritDoc SchemaStatics.optionalRecursive}\n\t /\n\tpublic override readonly optionalRecursive = schemaStatics.optionalRecursive;\n\n\t/\n\t {@inheritDoc SchemaStatics.requiredRecursive}\n\t /\n\tpublic override readonly requiredRecursive = schemaStatics.requiredRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsAlpha.staged}\n\t /\n\tpublic static staged = schemaStaticsAlpha.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsAlpha.staged}\n\t /\n\tpublic staged = schemaStaticsAlpha.staged;\n\n\t/\n\t Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear as values in the map.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedMap extends factory.map(\"name\", factory.number, {\n\t * \tmetadata: { description: \"A map of numbers\" }\n\t * }) {}\n\t * ```\n\t /\n\tpublic mapAlpha<\n\t\tName extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): MapNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn mapSchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tallowedTypes,\n\t\t\ttrue,\n\t\t\ttrue,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactory.objectRecursive}\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override mapRecursive<\n\t\tName extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\treturn this.mapAlpha(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\toptions,\n\t\t) as unknown as MapNodeCustomizableSchemaUnsafe<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tT,\n\t\t\tTCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t Define a {@link TreeNodeSchemaClass} for a {@link (TreeArrayNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear in the array.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedArray extends factory.arrayAlpha(\"name\", factory.number) {}\n\t * ```\n\t /\n\tpublic arrayAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): ArrayNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn arraySchema(\n\t\t\tscoped<TScope, TName, Name>(this, name),\n\t\t\tallowedTypes,\n\t\t\ttrue,\n\t\t\ttrue,\n\t\t\toptions?.metadata,\n\t\t\toptions?.persistedMetadata,\n\t\t);\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactory.objectRecursive}\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override arrayRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\treturn this.arrayAlpha(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\toptions,\n\t\t) as unknown as ArrayNodeCustomizableSchemaUnsafe<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tT,\n\t\t\tTCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.\n\t \n\t @param name - Unique identifier for this schema within this factory's scope.\n\t * @param allowedTypes - The types that may appear in the record.\n\t * @param options - Additional options for the schema.\n\t \n\t @example\n\t * ```typescript\n\t * class NamedRecord extends factory.recordAlpha(\"name\", factory.number) {}\n\t * ```\n\t /\n\tpublic recordAlpha<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAnnotatedAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptionsAlpha<TCustomMetadata>,\n\t): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {\n\t\treturn recordSchema({\n\t\t\tidentifier: scoped<TScope, TName, Name>(this, name),\n\t\t\tinfo: allowedTypes,\n\t\t\tcustomizable: true,\n\t\t\timplicitlyConstructable: true,\n\t\t\tmetadata: options?.metadata,\n\t\t\tpersistedMetadata: options?.persistedMetadata,\n\t\t});\n\t}\n\n\t/\n\t {@link SchemaFactoryBeta.(record:2)} except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override recordRecursive<\n\t\tName extends TName,\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>) {\n\t\tconst RecordSchema = recordSchema({\n\t\t\tidentifier: scoped<TScope, TName, Name>(this, name),\n\t\t\tinfo: allowedTypes as T & ImplicitAllowedTypes,\n\t\t\tcustomizable: true,\n\t\t\t// Setting this to true seems to work ok currently, but not for other node kinds.\n\t\t\t// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.\n\t\t\timplicitlyConstructable: false,\n\t\t\tmetadata: options?.metadata,\n\t\t\tpersistedMetadata: options?.persistedMetadata,\n\t\t});\n\n\t\treturn RecordSchema as TreeNodeSchemaClass<\n\t\t\t/ Name / ScopedSchemaName<TScope, Name>,\n\t\t\t/ Kind / NodeKind.Record,\n\t\t\t/ TNode / TreeRecordNodeUnsafe<T> &\n\t\t\t\tWithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>,\n\t\t\t/ TInsertable / {\n\t\t\t\t// Ideally this would be\n\t\t\t\t// RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,\n\t\t\t\t// but doing so breaks recursive types.\n\t\t\t\t// Instead we do a less nice version:\n\t\t\t\treadonly [P in string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;\n\t\t\t},\n\t\t\t/ ImplicitlyConstructable / false,\n\t\t\t/ Info / T,\n\t\t\t/ TConstructorExtra / undefined,\n\t\t\t/ TCustomMetadata / TCustomMetadata\n\t\t>;\n\t}\n\n\t/\n\t {@inheritDoc SchemaFactoryBeta.scopedFactory}\n\t */\n\tpublic scopedFactoryAlpha<\n\t\tconst T extends TName,\n\t\tTNameInner extends number \| string = string,\n\t>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner> {\n\t\treturn new SchemaFactoryAlpha(scoped<TScope, TName, T>(this, name));\n\t}\n}\n"]}

package/dist/simple-tree/api/schemaFactoryBeta.d.ts CHANGED Viewed

@@ -2,7 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
+import type { ImplicitAllowedTypes, NodeKind, TreeNodeSchema, TreeNodeSchemaClass, TreeNodeSchemaNonClass, WithType } from "../core/index.js";
+import { type RecordNodeInsertableData, type TreeRecordNode } from "../node-kinds/index.js";
+import { SchemaFactory, type NodeSchemaOptions, type ScopedSchemaName } from "./schemaFactory.js";
+import type { System_Unsafe, TreeRecordNodeUnsafe } from "./typesUnsafe.js";
 /**
  * {@link SchemaFactory} with additional beta APIs.
  * @beta
@@ -16,5 +19,91 @@ export declare class SchemaFactoryBeta<out TScope extends string | undefined = s
      * Creating such related schema using a sub-scope helps ensure they won't collide with other schema in the parent scope.
      */
     scopedFactory<const T extends TName, TNameInner extends number | string = string>(name: T): SchemaFactoryBeta<ScopedSchemaName<TScope, T>, TNameInner>;
+    /**
+     * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
+     *
+     * @param allowedTypes - The types that may appear in the record.
+     *
+     * @remarks
+     * The identifier for this record is defined as a function of the provided types.
+     * It is still scoped to this `SchemaFactory`, but multiple calls with the same arguments will return the same
+     * schema object, providing somewhat structural typing.
+     * This does not support recursive types.
+     *
+     * If using these structurally named records, other types in this schema builder should avoid names of the form `Record<${string}>`.
+     *
+     * The underlying data format for `Record` nodes is the same as that for `Map` nodes.
+     * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is
+     * a non-breaking change and does not require schema migration.
+     *
+     * @example
+     * The returned schema should be used as a schema directly:
+     * ```typescript
+     * const MyRecord = factory.record(factory.number);
+     * type MyRecord = NodeFromSchema<typeof Record>;
+     * ```
+     * Or inline:
+     * ```typescript
+     * factory.object("Foo", { myRecord: factory.record(factory.number) });
+     * ```
+     *
+     * @privateRemarks
+     * The name produced at the type-level here is not as specific as it could be; however, doing type-level sorting and escaping is a real mess.
+     * There are cases where not having this full type provided will be less than ideal, since TypeScript's structural types will allow assignment between runtime incompatible types at compile time.
+     * For example, attempts to narrow unions of structural records by name won't work.
+     * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
+     * though there may still be some problematic cases even after that work is done.
+     *
+     * The return value is a class, but its type is intentionally not specific enough to indicate it is a class.
+     * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls to this different subclasses)
+     * when working with structural typing.
+     *
+     * {@label STRUCTURAL}
+     */
+    record<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
+    /**
+     * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
+     *
+     * @param name - Unique identifier for this schema within this factory's scope.
+     * @param allowedTypes - The types that may appear in the record.
+     *
+     * @remarks
+     * The underlying data format for `Record` nodes is the same as that for `Map` nodes.
+     * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is
+     * a non-breaking change and does not require schema migration.
+     *
+     * Like TypeScript `Record`s, record nodes have some potential pitfalls.
+     * For example: TypeScript makes assumptions about built-in keys being present (e.g. `toString`, `hasOwnProperty`, etc.).
+     * Since these are otherwise valid keys in a record, this can lead to unexpected behavior.
+     * To prevent inconsistent behavior, these built-ins are hidden by record nodes.
+     * This means that if you try to call these built-ins (e.g. `toString()`) on a record node, you will get an error.
+     *
+     * @example
+     * ```typescript
+     * class NamedRecord extends factory.record("name", factory.number) {}
+     * ```
+     *
+     * {@label NAMED}
+     */
+    record<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
+    /**
+     * Define a {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
+     *
+     * @param name - Unique identifier for this schema within this factory's scope.
+     *
+     * @remarks
+     * This is not intended to be used directly, use the overload of `record` which takes a name instead.
+     */
+    private namedRecord;
+    /**
+     * {@link SchemaFactoryBeta.(record:2)} except tweaked to work better for recursive types.
+     * Use with {@link ValidateRecursiveSchema} for improved type safety.
+     * @remarks
+     * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.
+     * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+     */
+    recordRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptions<TCustomMetadata>): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Record, TreeRecordNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record, unknown>, {
+        readonly [x: string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;
+    }, false, T, undefined, TCustomMetadata>;
 }
 //# sourceMappingURL=schemaFactoryBeta.d.ts.map

package/dist/simple-tree/api/schemaFactoryBeta.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryBeta.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryBeta.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,~~EAAE~~,aAAa,~~EAAU~~,KAAK,gBAAgB,~~EAAE~~,MAAM,oBAAoB,CAAC;~~AAElF~~;;;;GAIG;AACH,qBAAa,iBAAiB,CAC7B,GAAG,CAAC,MAAM,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,EAC1D,KAAK,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CACrC,SAAQ,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC;IACrC;;;;;OAKG;IACI,aAAa,CAAC,KAAK,CAAC,CAAC,SAAS,KAAK,EAAE,UAAU,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACtF,IAAI,EAAE,CAAC,GACL,iBAAiB,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC;~~CAG7D~~"}
1	+ {"version":3,"file":"schemaFactoryBeta.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryBeta.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACX,oBAAoB,EACpB,QAAQ,EACR,cAAc,EAEd,mBAAmB,EACnB,sBAAsB,EACtB,QAAQ,EACR,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAEN,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACN,aAAa,EAGb,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAc5E;;;;GAIG;AACH,qBAAa,iBAAiB,CAC7B,GAAG,CAAC,MAAM,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,EAC1D,KAAK,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CACrC,SAAQ,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC;IACrC;;;;;OAKG;IACI,aAAa,CAAC,KAAK,CAAC,CAAC,SAAS,KAAK,EAAE,UAAU,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACtF,IAAI,EAAE,CAAC,GACL,iBAAiB,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACI,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,cAAc,EAAE,EACvE,YAAY,EAAE,CAAC,GACb,sBAAsB,CACb,gBAAgB,CAAC,MAAM,EAAE,UAAU,MAAM,GAAG,CAAC,EAC7C,QAAQ,CAAC,MAAM,EACd,cAAc,CAAC,CAAC,CAAC,GAC5B,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,UAAU,MAAM,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvD,wBAAwB,CAAC,CAAC,CAAC,EACf,IAAI,EACvB,CAAC,EACY,SAAS,CACjC;IACD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACI,MAAM,CAAC,KAAK,CAAC,IAAI,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC,SAAS,oBAAoB,EAC3E,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,CAAC,GACb,mBAAmB,CACV,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,EAC9B,QAAQ,CAAC,MAAM,EACd,cAAc,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvE,wBAAwB,CAAC,CAAC,CAAC,EACf,IAAI,EACvB,CAAC,EACY,SAAS,CACjC;IAuDD;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAyCnB;;;;;;OAMG;IAEI,eAAe,CACrB,IAAI,SAAS,KAAK,EAClB,KAAK,CAAC,CAAC,SAAS,aAAa,CAAC,0BAA0B,EACxD,KAAK,CAAC,eAAe,GAAG,OAAO,EAC9B,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,eAAe,CAAC;;;CA6B3E"}