npm - @fluidframework/tree - Versions diffs - 2.81.0-374083 → 2.81.1 - Mend

@fluidframework/tree 2.81.0-374083 → 2.81.1

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 (1522) hide show

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,EAIN,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,EACb,MAAM,kBAAkB,CAAC;~~AAE1B~~,OAAO,EAGN,KAAK,gCAAgC,EACrC,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,MAAM,wBAAwB,CAAC;~~AAChC~~,OAAO,EAEN,aAAa,EAGb,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACX,+BAA+B,EAC/B,0BAA0B,EAC1B,aAAa,EACb,oBAAoB,EACpB,2BAA2B,EAC3B,UAAU,EACV,MAAM,kBAAkB,CAAC;~~AAI1B,OAAO,KAAK,EAKX,mBAAmB,EACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGnE~~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"}
1	+ {"version":3,"file":"schemaFactoryBeta.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryBeta.ts"],"names":[],"mappings":"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"}

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

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaFactoryBeta = void 0;
 const index_js_1 = require("../core/index.js");
+/* eslint-enable unused-imports/no-unused-imports, import-x/no-duplicates */
 const index_js_2 = require("../node-kinds/index.js");
 const schemaFactory_js_1 = require("./schemaFactory.js");
 const staged = (t) => {

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryBeta.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryBeta.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\tAnnotatedAllowedTypesInternal,\n\tcreateSchemaUpgrade,\n\tnormalizeToAnnotatedAllowedType,\n\ttype AllowedTypesFullFromMixed,\n\ttype AllowedTypesMetadata,\n\ttype AnnotatedAllowedType,\n\ttype ImplicitAllowedTypes,\n\ttype LazyItem,\n\ttype NodeKind,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaBoth,\n\ttype TreeNodeSchemaClass,\n\ttype TreeNodeSchemaNonClass,\n\ttype WithType,\n} from \"../core/index.js\";\n\nimport {\n\tobjectSchema,\n\trecordSchema,\n\ttype InsertableObjectFromSchemaRecord,\n\ttype RecordNodeInsertableData,\n\ttype TreeObjectNode,\n\ttype TreeRecordNode,\n} from \"../node-kinds/index.js\";\nimport {\n\tdefaultSchemaFactoryObjectOptions,\n\tSchemaFactory,\n\tscoped,\n\tstructuralName,\n\ttype NodeSchemaOptions,\n\ttype ObjectSchemaOptions,\n\ttype ScopedSchemaName,\n} from \"./schemaFactory.js\";\nimport type {\n\tAllowedTypesFullFromMixedUnsafe,\n\tAnnotatedAllowedTypeUnsafe,\n\tSystem_Unsafe,\n\tTreeRecordNodeUnsafe,\n\tUnannotateAllowedTypeUnsafe,\n\tUnenforced,\n} from \"./typesUnsafe.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-x/no-duplicates /\nimport type {\n\tFieldProps,\n\tFieldSchemaAlpha,\n\tFieldPropsAlpha,\n\tFieldKind,\n\tImplicitFieldSchema,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema } from \"../leafNodeSchema.js\";\nimport type { SimpleLeafNodeSchema } from \"../simpleSchema.js\";\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\n/ eslint-enable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import-x/no-duplicates /\n\n/\n Stateless APIs exposed via {@link SchemaFactoryBeta} as both instance properties and as statics.\n * @see {@link SchemaStatics} for why this is useful.\n * @system @sealed @beta\n /\nexport interface SchemaStaticsBeta {\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 For recursive schemas, use {@link SchemaStaticsBeta.stagedRecursive} instead.\n\t * It offers equivalent runtime behavior with relaxed compile-time typing for recursive type.\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\treadonly staged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t) => AnnotatedAllowedType<T>;\n\n\t/\n\t Normalize information about a set of {@link AllowedTypes} into an {@link AllowedTypesFull}.\n\t * @remarks\n\t * This can take in {@link AnnotatedAllowedType} to preserve their annotations.\n\t /\n\treadonly types: <\n\t\tconst T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n\t>(\n\t\tt: T,\n\t\tmetadata?: AllowedTypesMetadata,\n\t) => AllowedTypesFullFromMixed<T>;\n\n\t/\n\t {@link SchemaStaticsBeta.staged} 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 {@link SchemaStaticsBeta.staged} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\tstagedRecursive: <\n\t\tconst T extends Unenforced<AnnotatedAllowedType \| LazyItem<TreeNodeSchema>>,\n\t>(\n\t\tt: T,\n\t) => AnnotatedAllowedTypeUnsafe<UnannotateAllowedTypeUnsafe<T>>;\n\n\t/\n\t {@link SchemaStaticsBeta.types} 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 {@link SchemaStaticsBeta.types} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t * @privateRemarks\n\t * If all inputs (at least recursive ones) were required to be annotated, this could be typed more strongly.\n\t * In that case it could use `T extends readonly (AnnotatedAllowedTypeUnsafe \| LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>)[]`.\n\t /\n\treadonly typesRecursive: <\n\t\tconst T extends readonly Unenforced<AnnotatedAllowedType \| LazyItem<TreeNodeSchema>>[],\n\t>(\n\t\tt: T,\n\t\tmetadata?: AllowedTypesMetadata,\n\t) => AllowedTypesFullFromMixedUnsafe<T>;\n}\n\nconst staged = <const T extends LazyItem<TreeNodeSchema>>(\n\tt: T \| AnnotatedAllowedType<T>,\n): AnnotatedAllowedType<T> => {\n\tconst annotatedType = normalizeToAnnotatedAllowedType(t);\n\treturn {\n\t\ttype: annotatedType.type,\n\t\tmetadata: {\n\t\t\t...annotatedType.metadata,\n\t\t\tstagedSchemaUpgrade: createSchemaUpgrade(),\n\t\t},\n\t};\n};\n\nconst types = <const T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[]>(\n\tt: T,\n\tmetadata: AllowedTypesMetadata = {},\n): AllowedTypesFullFromMixed<T> => {\n\treturn AnnotatedAllowedTypesInternal.createMixed<T>(t, metadata);\n};\n\nconst schemaStaticsBeta: SchemaStaticsBeta = {\n\tstaged,\n\ttypes,\n\n\tstagedRecursive: staged as SchemaStaticsBeta[\"stagedRecursive\"],\n\ttypesRecursive: types as unknown as SchemaStaticsBeta[\"typesRecursive\"],\n};\n\n/\n {@link SchemaFactory} with additional beta APIs.\n * @beta\n * @privateRemarks\n /\nexport class SchemaFactoryBeta<\n\tout TScope extends string \| undefined = string \| undefined,\n\tTName extends number \| string = string,\n> extends SchemaFactory<TScope, TName> {\n\t/\n\t {@inheritDoc SchemaStaticsBeta.staged}\n\t /\n\tpublic static staged = schemaStaticsBeta.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.staged}\n\t /\n\tpublic staged = schemaStaticsBeta.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.stagedRecursive}\n\t /\n\tpublic static stagedRecursive = schemaStaticsBeta.stagedRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.stagedRecursive}\n\t /\n\tpublic stagedRecursive = schemaStaticsBeta.stagedRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.types}\n\t /\n\tpublic static types = schemaStaticsBeta.types;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.types}\n\t /\n\tpublic types = schemaStaticsBeta.types;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.typesRecursive}\n\t /\n\tpublic static typesRecursive = schemaStaticsBeta.typesRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.typesRecursive}\n\t /\n\tpublic typesRecursive = schemaStaticsBeta.typesRecursive;\n\n\t/\n\t Create a {@link SchemaFactory} with a {@link SchemaFactory.scope\|scope} which is a combination of this factory's scope and the provided name.\n\t * @remarks\n\t * The main use-case for this is when creating a collection of related schema (for example using a function that creates multiple schema).\n\t * Creating such related schema using a sub-scope helps ensure they won't collide with other schema in the parent scope.\n\t /\n\tpublic scopedFactory<const T extends TName, TNameInner extends number \| string = string>(\n\t\tname: T,\n\t): SchemaFactoryBeta<ScopedSchemaName<TScope, T>, TNameInner> {\n\t\treturn new SchemaFactoryBeta(scoped<TScope, TName, T>(this, name));\n\t}\n\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 override object<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<ImplicitFieldSchema>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: ObjectSchemaOptions<TCustomMetadata>,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Object,\n\t\tTreeObjectNode<T, ScopedSchemaName<TScope, Name>>,\n\t\tobject & InsertableObjectFromSchemaRecord<T>,\n\t\ttrue,\n\t\tT,\n\t\tnever,\n\t\tTCustomMetadata\n\t> {\n\t\treturn objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {\n\t\t\t...defaultSchemaFactoryObjectOptions,\n\t\t\t...options,\n\t\t});\n\t}\n\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?: ObjectSchemaOptions<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\ttype TScopedName = ScopedSchemaName<TScope, Name>;\n\t\treturn this.object(\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}\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 The underlying data format for `Record` nodes is the same as that for `Map` nodes.\n\t * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is\n\t * a non-breaking change and does not require schema migration.\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\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 @remarks\n\t * The underlying data format for `Record` nodes is the same as that for `Map` nodes.\n\t * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is\n\t * a non-breaking change and does not require schema migration.\n\t \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 @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<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptions<TCustomMetadata>,\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\t/ TCustomMetadata / TCustomMetadata\n\t>;\n\n\t/\n\t {@link SchemaFactoryBeta.record} implementation.\n\t \n\t @privateRemarks\n\t * This should return {@link TreeNodeSchemaBoth}: see note on {@link SchemaFactory.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\toptions?: NodeSchemaOptions,\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 nodeTypes = nameOrAllowedTypes as (T & TreeNodeSchema) \| readonly TreeNodeSchema[];\n\t\t\tconst fullName = structuralName(\"Record\", nodeTypes);\n\t\t\treturn this.getStructuralType(fullName, nodeTypes, () =>\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\toptions,\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?: NodeSchemaOptions<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\treturn 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\tnodeOptions: options,\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 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?: NodeSchemaOptions<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"]}
1	+ {"version":3,"file":"schemaFactoryBeta.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryBeta.ts"],"names":[],"mappings":"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","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\n// eslint-disable-next-line unused-imports/no-unused-imports, import-x/no-duplicates -- This import prevents a large number of type references in the API reports from showing up as _2.\nimport type { RestrictiveStringRecord as _RestrictiveStringRecord } from \"../../util/index.js\";\nimport {\n\tAnnotatedAllowedTypesInternal,\n\tcreateSchemaUpgrade,\n\tnormalizeToAnnotatedAllowedType,\n\ttype AllowedTypesFullFromMixed,\n\ttype AllowedTypesMetadata,\n\ttype AnnotatedAllowedType,\n\ttype ImplicitAllowedTypes,\n\ttype LazyItem,\n\ttype NodeKind,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaBoth,\n\ttype TreeNodeSchemaClass,\n\ttype TreeNodeSchemaNonClass,\n\ttype WithType,\n} from \"../core/index.js\";\nimport type { ImplicitFieldSchema } from \"../fieldSchema.js\";\n/* eslint-disable unused-imports/no-unused-imports, import-x/no-duplicates -- These imports prevent a large number of type references in the API reports from showing up as _2. /\nimport type {\n\tFieldProps as _FieldProps,\n\tFieldSchemaAlpha as _FieldSchemaAlpha,\n\tFieldPropsAlpha as _FieldPropsAlpha,\n\tFieldKind as _FieldKind,\n\tImplicitFieldSchema as _ImplicitFieldSchema,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema as _LeafSchema } from \"../leafNodeSchema.js\";\n/* eslint-enable unused-imports/no-unused-imports, import-x/no-duplicates /\nimport {\n\tobjectSchema,\n\trecordSchema,\n\ttype InsertableObjectFromSchemaRecord,\n\ttype RecordNodeInsertableData,\n\ttype TreeObjectNode,\n\ttype TreeRecordNode,\n} from \"../node-kinds/index.js\";\n// eslint-disable-next-line unused-imports/no-unused-imports -- This import prevents a large number of type references in the API reports from showing up as _2.\nimport type { SimpleLeafNodeSchema as _SimpleLeafNodeSchema } from \"../simpleSchema.js\";\n\nimport {\n\tdefaultSchemaFactoryObjectOptions,\n\tSchemaFactory,\n\tscoped,\n\tstructuralName,\n\ttype NodeSchemaOptions,\n\ttype ObjectSchemaOptions,\n\ttype ScopedSchemaName,\n} from \"./schemaFactory.js\";\nimport type {\n\tAllowedTypesFullFromMixedUnsafe,\n\tAnnotatedAllowedTypeUnsafe,\n\tSystem_Unsafe,\n\tTreeRecordNodeUnsafe,\n\tUnannotateAllowedTypeUnsafe,\n\tUnenforced,\n} from \"./typesUnsafe.js\";\n\n/*\n Stateless APIs exposed via {@link SchemaFactoryBeta} as both instance properties and as statics.\n * @see {@link SchemaStatics} for why this is useful.\n * @system @sealed @beta\n /\nexport interface SchemaStaticsBeta {\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 For recursive schemas, use {@link SchemaStaticsBeta.stagedRecursive} instead.\n\t * It offers equivalent runtime behavior with relaxed compile-time typing for recursive type.\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\treadonly staged: <const T extends LazyItem<TreeNodeSchema>>(\n\t\tt: T \| AnnotatedAllowedType<T>,\n\t) => AnnotatedAllowedType<T>;\n\n\t/\n\t Normalize information about a set of {@link AllowedTypes} into an {@link AllowedTypesFull}.\n\t * @remarks\n\t * This can take in {@link AnnotatedAllowedType} to preserve their annotations.\n\t /\n\treadonly types: <\n\t\tconst T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[],\n\t>(\n\t\tt: T,\n\t\tmetadata?: AllowedTypesMetadata,\n\t) => AllowedTypesFullFromMixed<T>;\n\n\t/\n\t {@link SchemaStaticsBeta.staged} 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 {@link SchemaStaticsBeta.staged} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\tstagedRecursive: <\n\t\tconst T extends Unenforced<AnnotatedAllowedType \| LazyItem<TreeNodeSchema>>,\n\t>(\n\t\tt: T,\n\t) => AnnotatedAllowedTypeUnsafe<UnannotateAllowedTypeUnsafe<T>>;\n\n\t/\n\t {@link SchemaStaticsBeta.types} 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 {@link SchemaStaticsBeta.types} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t * @privateRemarks\n\t * If all inputs (at least recursive ones) were required to be annotated, this could be typed more strongly.\n\t * In that case it could use `T extends readonly (AnnotatedAllowedTypeUnsafe \| LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>)[]`.\n\t /\n\treadonly typesRecursive: <\n\t\tconst T extends readonly Unenforced<AnnotatedAllowedType \| LazyItem<TreeNodeSchema>>[],\n\t>(\n\t\tt: T,\n\t\tmetadata?: AllowedTypesMetadata,\n\t) => AllowedTypesFullFromMixedUnsafe<T>;\n}\n\nconst staged = <const T extends LazyItem<TreeNodeSchema>>(\n\tt: T \| AnnotatedAllowedType<T>,\n): AnnotatedAllowedType<T> => {\n\tconst annotatedType = normalizeToAnnotatedAllowedType(t);\n\treturn {\n\t\ttype: annotatedType.type,\n\t\tmetadata: {\n\t\t\t...annotatedType.metadata,\n\t\t\tstagedSchemaUpgrade: createSchemaUpgrade(),\n\t\t},\n\t};\n};\n\nconst types = <const T extends readonly (AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[]>(\n\tt: T,\n\tmetadata: AllowedTypesMetadata = {},\n): AllowedTypesFullFromMixed<T> => {\n\treturn AnnotatedAllowedTypesInternal.createMixed<T>(t, metadata);\n};\n\nconst schemaStaticsBeta: SchemaStaticsBeta = {\n\tstaged,\n\ttypes,\n\n\tstagedRecursive: staged as SchemaStaticsBeta[\"stagedRecursive\"],\n\ttypesRecursive: types as unknown as SchemaStaticsBeta[\"typesRecursive\"],\n};\n\n/\n {@link SchemaFactory} with additional beta APIs.\n * @beta\n * @privateRemarks\n /\nexport class SchemaFactoryBeta<\n\tout TScope extends string \| undefined = string \| undefined,\n\tTName extends number \| string = string,\n> extends SchemaFactory<TScope, TName> {\n\t/\n\t {@inheritDoc SchemaStaticsBeta.staged}\n\t /\n\tpublic static staged = schemaStaticsBeta.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.staged}\n\t /\n\tpublic staged = schemaStaticsBeta.staged;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.stagedRecursive}\n\t /\n\tpublic static stagedRecursive = schemaStaticsBeta.stagedRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.stagedRecursive}\n\t /\n\tpublic stagedRecursive = schemaStaticsBeta.stagedRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.types}\n\t /\n\tpublic static types = schemaStaticsBeta.types;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.types}\n\t /\n\tpublic types = schemaStaticsBeta.types;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.typesRecursive}\n\t /\n\tpublic static typesRecursive = schemaStaticsBeta.typesRecursive;\n\n\t/\n\t {@inheritDoc SchemaStaticsBeta.typesRecursive}\n\t /\n\tpublic typesRecursive = schemaStaticsBeta.typesRecursive;\n\n\t/\n\t Create a {@link SchemaFactory} with a {@link SchemaFactory.scope\|scope} which is a combination of this factory's scope and the provided name.\n\t * @remarks\n\t * The main use-case for this is when creating a collection of related schema (for example using a function that creates multiple schema).\n\t * Creating such related schema using a sub-scope helps ensure they won't collide with other schema in the parent scope.\n\t /\n\tpublic scopedFactory<const T extends TName, TNameInner extends number \| string = string>(\n\t\tname: T,\n\t): SchemaFactoryBeta<ScopedSchemaName<TScope, T>, TNameInner> {\n\t\treturn new SchemaFactoryBeta(scoped<TScope, TName, T>(this, name));\n\t}\n\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 override object<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveStringRecord<ImplicitFieldSchema>,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: ObjectSchemaOptions<TCustomMetadata>,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Object,\n\t\tTreeObjectNode<T, ScopedSchemaName<TScope, Name>>,\n\t\tobject & InsertableObjectFromSchemaRecord<T>,\n\t\ttrue,\n\t\tT,\n\t\tnever,\n\t\tTCustomMetadata\n\t> {\n\t\treturn objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {\n\t\t\t...defaultSchemaFactoryObjectOptions,\n\t\t\t...options,\n\t\t});\n\t}\n\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?: ObjectSchemaOptions<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\ttype TScopedName = ScopedSchemaName<TScope, Name>;\n\t\treturn this.object(\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}\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 The underlying data format for `Record` nodes is the same as that for `Map` nodes.\n\t * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is\n\t * a non-breaking change and does not require schema migration.\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\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 @remarks\n\t * The underlying data format for `Record` nodes is the same as that for `Map` nodes.\n\t * Therefore, changing an existing `Map` schema to a `Record` schema (or vice versa) is\n\t * a non-breaking change and does not require schema migration.\n\t \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 @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<\n\t\tconst Name extends TName,\n\t\tconst T extends ImplicitAllowedTypes,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\toptions?: NodeSchemaOptions<TCustomMetadata>,\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\t/ TCustomMetadata / TCustomMetadata\n\t>;\n\n\t/\n\t {@link SchemaFactoryBeta.record} implementation.\n\t \n\t @privateRemarks\n\t * This should return {@link TreeNodeSchemaBoth}: see note on {@link SchemaFactory.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\toptions?: NodeSchemaOptions,\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 nodeTypes = nameOrAllowedTypes as (T & TreeNodeSchema) \| readonly TreeNodeSchema[];\n\t\t\tconst fullName = structuralName(\"Record\", nodeTypes);\n\t\t\treturn this.getStructuralType(fullName, nodeTypes, () =>\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\toptions,\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?: NodeSchemaOptions<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\treturn 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\tnodeOptions: options,\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 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?: NodeSchemaOptions<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"]}

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

@@ -4,8 +4,8 @@
  */
 import type { RestrictiveStringRecord } from "../../util/index.js";
 import type { NodeKind, TreeNodeSchema, WithType, TreeNode, ImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, TreeNodeSchemaClass } from "../core/index.js";
-import type { InsertableObjectFromSchemaRecord } from "../node-kinds/index.js";
 import type { ImplicitFieldSchema } from "../fieldSchema.js";
+import type { InsertableObjectFromSchemaRecord } from "../node-kinds/index.js";
 /**
  * Compile time check for validity of a recursive schema.
  * This type also serves as a central location for documenting the requirements and issues related to recursive schema.

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryRecursive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EACX,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,oBAAoB,EACpB,0CAA0C,EAC1C,mBAAmB,EACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,~~gCAAgC~~,EAAE,MAAM,~~wBAAwB~~,CAAC;~~AAC/E~~,OAAO,KAAK,EAAE,~~mBAAmB~~,EAAE,MAAM,~~mBAAmB~~,CAAC;~~AAE7D~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,+BAA+B,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAEzF;;;;;GAKG;AACH,MAAM,MAAM,+BAA+B,CAAC,CAAC,SAAS,mBAAmB,IACxE,mBAAmB,CAElB,MAAM,EAEN,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,EAEjE,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAG/C;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,uBAAuB,CAAC,mBAAmB,CAAC,GAC9E,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;IACX,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;QAClB,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,0CAA0C,CAAC,CAAC,CAAC;KACrE,CAAC;IACF,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAEZ,KAAK,EAEL;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;IAChE,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IACvC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,CAAC;IACrC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IACxC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CACZ,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,mBAAmB,IACnE,CAAC,SAAS,+BAA+B,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAG;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,CAAC"}
1	+ {"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryRecursive.ts"],"names":[],"mappings":"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"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryRecursive.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA+OH;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAI,CAAK,IAAS,CAAC;AAA9C,kCAA8C","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\nimport type {\n\tNodeKind,\n\tTreeNodeSchema,\n\tWithType,\n\tTreeNode,\n\tImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tTreeNodeSchemaClass,\n} from \"../core/index.js\";\nimport type { InsertableObjectFromSchemaRecord } from \"../node-kinds/index.js\";\nimport type { ImplicitFieldSchema } from \"../fieldSchema.js\";\n\n/\n Compile time check for validity of a recursive schema.\n * This type also serves as a central location for documenting the requirements and issues related to 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 * In this context recursive schema are defined as all {@link FieldSchema} and {@link TreeNodeSchema} schema which are part of a cycle such that walking down through each {@link TreeNodeSchemaCore.childTypes} the given starting schema can be reached again.\n * Schema referencing the recursive schema and schema they reference that are not part of a cycle are not considered recursive.\n \n TypeScript puts a lot of limitations on the typing of recursive schema.\n * To help avoid running into these limitations and thus getting schema that do not type check (or only type checks sometimes!),\n * {@link SchemaFactory} provides APIs (postfixed with `Recursive`) for writing recursive schema.\n * These APIs when combined with the patterns documented below should ensure that the schema provide robust type checking.\n * These special patterns (other than {@link LazyItem} forward references which are not recursion specific)\n * are not required for correct runtime behavior: they exist entirely to mitigate TypeScript type checking limitations and bugs.\n * Ideally TypeScript's type checker would be able to handle all of these cases and more, removing the need for recursive type specific guidance, rules and APIs.\n * Currently however there are open issues preventing this:\n * {@link https://github.com/microsoft/TypeScript/issues/59550 \| 1},\n * {@link https://github.com/microsoft/TypeScript/issues/55832 \| 2},\n * {@link https://github.com/microsoft/TypeScript/issues/55758 \| 3}.\n * Note that the proposed resolution to some of these issues is for the compiler to error rather than allow the case,\n * so even if these are all resolved the recursive type workarounds may still be needed.\n \n # Patterns\n \n Below are patterns for how to use recursive schema.\n \n ## General Patterns\n \n When defining a recursive {@link TreeNodeSchema}, use the `Recursive` {@link SchemaFactory} methods.\n The returned class should be used as the base class for the recursive schema, which should then be passed to {@link ValidateRecursiveSchema}.\n \n Using {@link ValidateRecursiveSchema} will provide compile error 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 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 a reference to a schema is malformed (in this case boxed inside an object):\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 If your TypeScript configuration objects to this patten due to the unused local, you can use {@link allowUnused} to suppress the error:\n \n ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => ({ Test })]) {} // Bad\n * allowUnused<ValidateRecursiveSchema<typeof Test>>(); // Reports compile error due to invalid schema above.\n * ```\n \n ## Object Schema\n \n When defining fields, if the fields is part of the recursive cycle, use the `Recursive` {@link SchemaFactory} methods for defining the {@link FieldSchema}.\n \n * ## Array Schema\n \n See {@link FixRecursiveArraySchema} for array specific details.\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 \n TODO: this currently does not reject `any`, but ideally should.\n * @public\n /\nexport type ValidateRecursiveSchema<T extends ValidateRecursiveSchemaTemplate<T>> = true;\n\n/\n Validation logic used by {@link ValidateRecursiveSchema}.\n * @privateRemarks\n * Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as that's part of the requirements for the type to work across compilation boundaries correctly.\n * @system @public\n /\nexport type ValidateRecursiveSchemaTemplate<T extends TreeNodeSchemaClass> =\n\tTreeNodeSchemaClass<\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 \| NodeKind.Record,\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\"], T[\"kind\"]>,\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 RestrictiveStringRecord<ImplicitFieldSchema>\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[NodeKind.Record]: {\n\t\t\t\treadonly [P in string]: InsertableTreeNodeFromImplicitAllowedTypes<T>;\n\t\t\t};\n\t\t\t[NodeKind.Leaf]: unknown;\n\t\t}[T[\"kind\"]],\n\t\t// ImplicitlyConstructable: recursive types are currently 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]: RestrictiveStringRecord<ImplicitFieldSchema>;\n\t\t\t[NodeKind.Array]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Map]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Record]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Leaf]: unknown;\n\t\t}[T[\"kind\"]]\n\t>;\n\n/\n Workaround for \"Type instantiation is excessively deep and possibly infinite.ts\" errors.\n * @remarks\n \n Generally this workaround should be avoided if possible,\n * especially for exported types, as it is likely to result in issues when exporting or importing schema where the user will be forced to use the workaround as well.\n * This is particularly problematic since in some cases it may not be possible for the user to replicate the pattern.\n * Additionally, which cases hit these limits may vary based on TypeScript version and implementation details of this library.\n \n This workaround is provided and documented as a last resort to be able to keep an app compiling.\n * Future version of SharedTree should provide schema type erasure functionality as a better alternative for most cases.\n \n When TypeScript gives the error \"Error (TS2589) Type instantiation is excessively deep and possibly infinite.\" on the invocation of `ValidateRecursiveSchema`\n * for a large schema, it can sometimes be worked around by repeating the usage of the type multiple times.\n * This works because the TypeScript compiler caches some of the intermediate results from the first usage, and thus can get further on the second.\n \n This utility can be referenced when applying this pattern.\n * For recursive types this can be used directly:\n \n ```typescript\n * {\n * // @ts-expect-error Recursion limit\n * type _check1 = FixRecursiveRecursionLimit<typeof LargeType>;\n * type _check2 = FixRecursiveRecursionLimit<typeof LargeType>;\n * type _check3 = ValidateRecursiveSchemaTemplate<typeof LargeType>;\n * }\n * ```\n \n For non-recursive types, they can be ported to the more flexible recursive APIs and use the pattern above.\n \n Non-recursive types can also use this workaround by making a duplicate copy of the problematic schema written using the recursive APIs.\n * Then this pattern can be applied to the duplicate copy.\n \n ```typescript\n * // Workaround TypeScript recursion limit\n * \t{\n * \t\tclass LargeUnionObjectNode_Fix extends schema.objectRecursive(\"ObjectNode\", {\n * \t\t\tx: largeUnion,\n * \t\t}) {}\n \n \t\t// @ts-expect-error Recursion limit\n * \t\tallowUnused<FixRecursiveRecursionLimit<typeof LargeUnionObjectNode_Fix>>();\n * \t\tallowUnused<FixRecursiveRecursionLimit<typeof LargeUnionObjectNode_Fix>>();\n * \t\tallowUnused<ValidateRecursiveSchema<typeof LargeUnionObjectNode_Fix>>();\n * \t\t}\n \n \t// Fails to compile without the above workaround.\n * \tclass LargeUnionObjectNode extends schema.object(\"ObjectNode\", { x: largeUnion }) {}\n * ```\n * @privateRemarks\n * Using this is real sketchy, and leads to a lot of issues (errors which depend on how the schema is compiled, making different build setups produce different results and complicating exports).\n * This is being kept as internal for now: if a customer really needs it, we have this as a documented workaround, but it would be much better to find an alternative solution before using this one.\n * This uses ValidateRecursiveSchemaTemplate since it was found to evaluate enough of the type to work.\n * @internal\n /\nexport type FixRecursiveRecursionLimit<T extends TreeNodeSchemaClass> =\n\tT extends ValidateRecursiveSchemaTemplate<T> ? undefined : undefined;\n\n/\n Does nothing with the provided value, but appears to use it to make unused locals warnings and errors go away.\n \n @remarks\n * When TypeScript is configured with \"noUnusedLocals\", it will produce an error if a local variable is declared but never used.\n * When you want to have this check enabled, but not follow it for a specific variable, you can pass the type or value to this function.\n \n Instead of using this, consider disabling \"noUnusedLocals\" in your tsconfig.json file, and enabling a similar check via a linter.\n * This will allow you to still have the check, but have more control over it, for example being able to suppress it, or enable patterns like allowing unused locals with an \"_\" prefix.\n * @alpha\n /\nexport function allowUnused<T>(t?: T): void {}\n\n/\n Workaround for fixing errors resulting from an issue with recursive ArrayNode schema exports.\n * @remarks\n * Importing a recursive ArrayNode schema via a d.ts file can produce an error like\n * `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.`\n * if using a tsconfig with `\"skipLibCheck\": false`.\n \n This error occurs due to the TypeScript compiler splitting the class definition into two separate declarations in the d.ts file (one for the base, and one for the actual class).\n * For unknown reasons, splitting the class declaration in this way breaks the recursive type handling, leading to the mentioned error.\n \n This type always evaluates to `undefined` to ensure the dummy export (which doesn't exist at runtime) is typed correctly.\n \n {@link https://github.com/microsoft/TypeScript/issues/59550\|TypeScript Issue 59550} tracks a suggestion which would make this workaround unnecessary.\n \n @example Usage\n * Since recursive type handling in TypeScript is order dependent, putting just the right kind of usages of the type before the declarations can cause it to not hit this error.\n * For the case of ArrayNodes, this can be done via usage that looks like this:\n \n This example should use a doc comment to ensure the workaround comment shows up in the intellisense for the dummy export,\n * however doing so is impossible due to how this example is included in a doc comment.\n * ```typescript\n * // Workaround to avoid\n * // `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.` in the d.ts file.\n * export declare type _RecursiveArrayWorkaround = FixRecursiveArraySchema<typeof RecursiveArray>;\n * export class RecursiveArray extends schema.arrayRecursive(\"RA\", [() => RecursiveArray]) {}\n * {\n * \ttype _check = ValidateRecursiveSchema<typeof RecursiveArray>;\n * }\n * ```\n \n @beta\n */\nexport type FixRecursiveArraySchema<T> = T extends TreeNodeSchema ? undefined : undefined;\n"]}
1	+ {"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFactoryRecursive.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA+OH;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAI,CAAK,IAAS,CAAC;AAA9C,kCAA8C","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport type { RestrictiveStringRecord } from \"../../util/index.js\";\nimport type {\n\tNodeKind,\n\tTreeNodeSchema,\n\tWithType,\n\tTreeNode,\n\tImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tTreeNodeSchemaClass,\n} from \"../core/index.js\";\nimport type { ImplicitFieldSchema } from \"../fieldSchema.js\";\nimport type { InsertableObjectFromSchemaRecord } from \"../node-kinds/index.js\";\n\n/\n Compile time check for validity of a recursive schema.\n * This type also serves as a central location for documenting the requirements and issues related to 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 * In this context recursive schema are defined as all {@link FieldSchema} and {@link TreeNodeSchema} schema which are part of a cycle such that walking down through each {@link TreeNodeSchemaCore.childTypes} the given starting schema can be reached again.\n * Schema referencing the recursive schema and schema they reference that are not part of a cycle are not considered recursive.\n \n TypeScript puts a lot of limitations on the typing of recursive schema.\n * To help avoid running into these limitations and thus getting schema that do not type check (or only type checks sometimes!),\n * {@link SchemaFactory} provides APIs (postfixed with `Recursive`) for writing recursive schema.\n * These APIs when combined with the patterns documented below should ensure that the schema provide robust type checking.\n * These special patterns (other than {@link LazyItem} forward references which are not recursion specific)\n * are not required for correct runtime behavior: they exist entirely to mitigate TypeScript type checking limitations and bugs.\n * Ideally TypeScript's type checker would be able to handle all of these cases and more, removing the need for recursive type specific guidance, rules and APIs.\n * Currently however there are open issues preventing this:\n * {@link https://github.com/microsoft/TypeScript/issues/59550 \| 1},\n * {@link https://github.com/microsoft/TypeScript/issues/55832 \| 2},\n * {@link https://github.com/microsoft/TypeScript/issues/55758 \| 3}.\n * Note that the proposed resolution to some of these issues is for the compiler to error rather than allow the case,\n * so even if these are all resolved the recursive type workarounds may still be needed.\n \n # Patterns\n \n Below are patterns for how to use recursive schema.\n \n ## General Patterns\n \n When defining a recursive {@link TreeNodeSchema}, use the `Recursive` {@link SchemaFactory} methods.\n The returned class should be used as the base class for the recursive schema, which should then be passed to {@link ValidateRecursiveSchema}.\n \n Using {@link ValidateRecursiveSchema} will provide compile error 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 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 a reference to a schema is malformed (in this case boxed inside an object):\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 If your TypeScript configuration objects to this patten due to the unused local, you can use {@link allowUnused} to suppress the error:\n \n ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => ({ Test })]) {} // Bad\n * allowUnused<ValidateRecursiveSchema<typeof Test>>(); // Reports compile error due to invalid schema above.\n * ```\n \n ## Object Schema\n \n When defining fields, if the fields is part of the recursive cycle, use the `Recursive` {@link SchemaFactory} methods for defining the {@link FieldSchema}.\n \n * ## Array Schema\n \n See {@link FixRecursiveArraySchema} for array specific details.\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 \n TODO: this currently does not reject `any`, but ideally should.\n * @public\n /\nexport type ValidateRecursiveSchema<T extends ValidateRecursiveSchemaTemplate<T>> = true;\n\n/\n Validation logic used by {@link ValidateRecursiveSchema}.\n * @privateRemarks\n * Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as that's part of the requirements for the type to work across compilation boundaries correctly.\n * @system @public\n /\nexport type ValidateRecursiveSchemaTemplate<T extends TreeNodeSchemaClass> =\n\tTreeNodeSchemaClass<\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 \| NodeKind.Record,\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\"], T[\"kind\"]>,\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 RestrictiveStringRecord<ImplicitFieldSchema>\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[NodeKind.Record]: {\n\t\t\t\treadonly [P in string]: InsertableTreeNodeFromImplicitAllowedTypes<T>;\n\t\t\t};\n\t\t\t[NodeKind.Leaf]: unknown;\n\t\t}[T[\"kind\"]],\n\t\t// ImplicitlyConstructable: recursive types are currently 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]: RestrictiveStringRecord<ImplicitFieldSchema>;\n\t\t\t[NodeKind.Array]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Map]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Record]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Leaf]: unknown;\n\t\t}[T[\"kind\"]]\n\t>;\n\n/\n Workaround for \"Type instantiation is excessively deep and possibly infinite.ts\" errors.\n * @remarks\n \n Generally this workaround should be avoided if possible,\n * especially for exported types, as it is likely to result in issues when exporting or importing schema where the user will be forced to use the workaround as well.\n * This is particularly problematic since in some cases it may not be possible for the user to replicate the pattern.\n * Additionally, which cases hit these limits may vary based on TypeScript version and implementation details of this library.\n \n This workaround is provided and documented as a last resort to be able to keep an app compiling.\n * Future version of SharedTree should provide schema type erasure functionality as a better alternative for most cases.\n \n When TypeScript gives the error \"Error (TS2589) Type instantiation is excessively deep and possibly infinite.\" on the invocation of `ValidateRecursiveSchema`\n * for a large schema, it can sometimes be worked around by repeating the usage of the type multiple times.\n * This works because the TypeScript compiler caches some of the intermediate results from the first usage, and thus can get further on the second.\n \n This utility can be referenced when applying this pattern.\n * For recursive types this can be used directly:\n \n ```typescript\n * {\n * // @ts-expect-error Recursion limit\n * type _check1 = FixRecursiveRecursionLimit<typeof LargeType>;\n * type _check2 = FixRecursiveRecursionLimit<typeof LargeType>;\n * type _check3 = ValidateRecursiveSchemaTemplate<typeof LargeType>;\n * }\n * ```\n \n For non-recursive types, they can be ported to the more flexible recursive APIs and use the pattern above.\n \n Non-recursive types can also use this workaround by making a duplicate copy of the problematic schema written using the recursive APIs.\n * Then this pattern can be applied to the duplicate copy.\n \n ```typescript\n * // Workaround TypeScript recursion limit\n * \t{\n * \t\tclass LargeUnionObjectNode_Fix extends schema.objectRecursive(\"ObjectNode\", {\n * \t\t\tx: largeUnion,\n * \t\t}) {}\n \n \t\t// @ts-expect-error Recursion limit\n * \t\tallowUnused<FixRecursiveRecursionLimit<typeof LargeUnionObjectNode_Fix>>();\n * \t\tallowUnused<FixRecursiveRecursionLimit<typeof LargeUnionObjectNode_Fix>>();\n * \t\tallowUnused<ValidateRecursiveSchema<typeof LargeUnionObjectNode_Fix>>();\n * \t\t}\n \n \t// Fails to compile without the above workaround.\n * \tclass LargeUnionObjectNode extends schema.object(\"ObjectNode\", { x: largeUnion }) {}\n * ```\n * @privateRemarks\n * Using this is real sketchy, and leads to a lot of issues (errors which depend on how the schema is compiled, making different build setups produce different results and complicating exports).\n * This is being kept as internal for now: if a customer really needs it, we have this as a documented workaround, but it would be much better to find an alternative solution before using this one.\n * This uses ValidateRecursiveSchemaTemplate since it was found to evaluate enough of the type to work.\n * @internal\n /\nexport type FixRecursiveRecursionLimit<T extends TreeNodeSchemaClass> =\n\tT extends ValidateRecursiveSchemaTemplate<T> ? undefined : undefined;\n\n/\n Does nothing with the provided value, but appears to use it to make unused locals warnings and errors go away.\n \n @remarks\n * When TypeScript is configured with \"noUnusedLocals\", it will produce an error if a local variable is declared but never used.\n * When you want to have this check enabled, but not follow it for a specific variable, you can pass the type or value to this function.\n \n Instead of using this, consider disabling \"noUnusedLocals\" in your tsconfig.json file, and enabling a similar check via a linter.\n * This will allow you to still have the check, but have more control over it, for example being able to suppress it, or enable patterns like allowing unused locals with an \"_\" prefix.\n * @alpha\n /\nexport function allowUnused<T>(t?: T): void {}\n\n/\n Workaround for fixing errors resulting from an issue with recursive ArrayNode schema exports.\n * @remarks\n * Importing a recursive ArrayNode schema via a d.ts file can produce an error like\n * `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.`\n * if using a tsconfig with `\"skipLibCheck\": false`.\n \n This error occurs due to the TypeScript compiler splitting the class definition into two separate declarations in the d.ts file (one for the base, and one for the actual class).\n * For unknown reasons, splitting the class declaration in this way breaks the recursive type handling, leading to the mentioned error.\n \n This type always evaluates to `undefined` to ensure the dummy export (which doesn't exist at runtime) is typed correctly.\n \n {@link https://github.com/microsoft/TypeScript/issues/59550\|TypeScript Issue 59550} tracks a suggestion which would make this workaround unnecessary.\n \n @example Usage\n * Since recursive type handling in TypeScript is order dependent, putting just the right kind of usages of the type before the declarations can cause it to not hit this error.\n * For the case of ArrayNodes, this can be done via usage that looks like this:\n \n This example should use a doc comment to ensure the workaround comment shows up in the intellisense for the dummy export,\n * however doing so is impossible due to how this example is included in a doc comment.\n * ```typescript\n * // Workaround to avoid\n * // `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.` in the d.ts file.\n * export declare type _RecursiveArrayWorkaround = FixRecursiveArraySchema<typeof RecursiveArray>;\n * export class RecursiveArray extends schema.arrayRecursive(\"RA\", [() => RecursiveArray]) {}\n * {\n * \ttype _check = ValidateRecursiveSchema<typeof RecursiveArray>;\n * }\n * ```\n \n @beta\n */\nexport type FixRecursiveArraySchema<T> = T extends TreeNodeSchema ? undefined : undefined;\n"]}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFromSimple.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFromSimple.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,OAAO,KAAK,EAKX,gBAAgB,EAChB,MAAM,oBAAoB,CAAC;~~AAE5B~~,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;~~AAKnD~~;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAmBnF"}
1	+ {"version":3,"file":"schemaFromSimple.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFromSimple.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,OAAO,KAAK,EAKX,gBAAgB,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAmBnF"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaFromSimple.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFromSimple.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 { unreachableCase, fail } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\tNodeKind,\n\ttype TreeNodeSchema,\n\ttype AllowedTypesFull,\n\tSchemaUpgrade,\n} from \"../core/index.js\";\nimport {\n\ttype FieldSchema,\n\ttype FieldSchemaAlpha,\n\tFieldKind,\n\ttype FieldProps,\n} from \"../fieldSchema.js\";\nimport type {\n\tSchemaType,\n\tSimpleAllowedTypeAttributes,\n\tSimpleFieldSchema,\n\tSimpleNodeSchema,\n\tSimpleTreeSchema,\n} from \"../simpleSchema.js\";\n\nimport type { TreeSchema } from \"../treeSchema.js\";\nimport { SchemaFactoryAlpha } from \"./schemaFactoryAlpha.js\";\n\nconst factory = new SchemaFactoryAlpha(undefined);\n\n/\n Create {@link FieldSchema} from a SimpleTreeSchema.\n * @remarks\n * Only use this API if hand written schema (produced using {@link SchemaFactory} cannot be provided.\n \n Using generated schema with schema aware APIs (designed to work with strongly typed schema) like {@link TreeViewConfiguration}\n * will produce a poor TypeScript typing experience which is subject to change.\n \n Editing through a view produced using this schema can easily violate invariants other users of the document might expect and must be done with great care.\n \n This API bakes in some arbitrary policy choices for how to handle data that is not included in the SimpleTreeSchema API, for example the value of `allowUnknownOptionalFields`.\n * If any particular choice is required for such cases, this API should not be used.\n \n @privateRemarks\n * TODO: Add the ability for consumers to inject custom policy.\n * For example, allow nodes with table schema identifiers to dispatch to `TableSchema` factory APIs.\n \n @alpha\n /\nexport function generateSchemaFromSimpleSchema(simple: SimpleTreeSchema): TreeSchema {\n\tconst context: Context = new Map(\n\t\t[...simple.definitions].map(\n\t\t\t([id, schema]): [string, () => TreeNodeSchema & SimpleNodeSchema<SchemaType.View>] => [\n\t\t\t\tid,\n\t\t\t\t// This relies on the caching in evaluateLazySchema so that it only runs once.\n\t\t\t\t() => generateNode(id, schema, context),\n\t\t\t],\n\t\t),\n\t);\n\tconst root = generateFieldSchema(simple.root, context, undefined);\n\tconst definitions = new Map<string, TreeNodeSchema & SimpleNodeSchema<SchemaType.View>>();\n\tfor (const [id, lazy] of context) {\n\t\tdefinitions.set(id, lazy());\n\t}\n\treturn {\n\t\troot,\n\t\tdefinitions,\n\t};\n}\n\ntype Context = ReadonlyMap<string, () => TreeNodeSchema & SimpleNodeSchema<SchemaType.View>>;\n\nfunction generateFieldSchema(\n\tsimple: SimpleFieldSchema,\n\tcontext: Context,\n\tstoredKey: string \| undefined,\n): FieldSchemaAlpha {\n\tconst allowed = generateAllowedTypes(simple.simpleAllowedTypes, context);\n\tconst props: Omit<FieldProps, \"defaultProvider\"> = {\n\t\tmetadata: simple.metadata,\n\t\tkey: storedKey,\n\t};\n\n\t// Using createFieldSchema could work, but would require setting up the default providers.\n\tswitch (simple.kind) {\n\t\tcase FieldKind.Identifier: {\n\t\t\treturn SchemaFactoryAlpha.identifier(props);\n\t\t}\n\t\tcase FieldKind.Optional: {\n\t\t\treturn SchemaFactoryAlpha.optional(allowed, props);\n\t\t}\n\t\tcase FieldKind.Required: {\n\t\t\treturn SchemaFactoryAlpha.required(allowed, props);\n\t\t}\n\t\tdefault: {\n\t\t\treturn unreachableCase(simple.kind);\n\t\t}\n\t}\n}\n\nfunction generateAllowedTypes(\n\tallowed: ReadonlyMap<string, SimpleAllowedTypeAttributes>,\n\tcontext: Context,\n): AllowedTypesFull {\n\tconst types = Array.from(allowed.entries(), ([id, attributes]) => {\n\t\tconst schema = context.get(id) ?? fail(0xb5a / Missing schema /);\n\t\treturn attributes.isStaged instanceof SchemaUpgrade ? factory.staged(schema) : schema;\n\t});\n\t// TODO: AB#53315: `AllowedTypesFullFromMixed` does not correctly handle the `(AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[]` case.\n\t// We have to cast here in order to produce an allowed types list that can be used in tree node factory methods (e.g., `SchemaFactoryAlpha.objectAlpha`).\n\treturn SchemaFactoryAlpha.types(types) as AllowedTypesFull;\n}\n\nfunction generateNode(\n\tid: string,\n\tschema: SimpleNodeSchema,\n\tcontext: Context,\n): TreeNodeSchema & SimpleNodeSchema<SchemaType.View> {\n\tswitch (schema.kind) {\n\t\tcase NodeKind.Object: {\n\t\t\tconst fields: Record<string, FieldSchema> = {};\n\t\t\tfor (const [key, field] of schema.fields) {\n\t\t\t\tfields[key] = generateFieldSchema(field, context, field.storedKey);\n\t\t\t}\n\t\t\t// Here allowUnknownOptionalFields is implicitly defaulting in the case where the input schema does not explicitly specify the value.\n\t\t\t// This is a subjective policy choice: users of this code are expected to handle what ever choice this code makes for cases like this.\n\t\t\treturn factory.objectAlpha(id, fields, {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t\tallowUnknownOptionalFields: schema.allowUnknownOptionalFields ?? false,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Array: {\n\t\t\treturn factory.arrayAlpha(id, generateAllowedTypes(schema.simpleAllowedTypes, context), {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Map: {\n\t\t\treturn factory.mapAlpha(id, generateAllowedTypes(schema.simpleAllowedTypes, context), {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Record: {\n\t\t\treturn factory.recordAlpha(\n\t\t\t\tid,\n\t\t\t\tgenerateAllowedTypes(schema.simpleAllowedTypes, context),\n\t\t\t\t{ metadata: schema.metadata },\n\t\t\t);\n\t\t}\n\t\tcase NodeKind.Leaf: {\n\t\t\treturn (\n\t\t\t\tSchemaFactoryAlpha.leaves.find((leaf) => leaf.identifier === id) ??\n\t\t\t\tfail(0xb5b / Missing schema */)\n\t\t\t);\n\t\t}\n\t\tdefault: {\n\t\t\treturn unreachableCase(schema);\n\t\t}\n\t}\n}\n"]}
1	+ {"version":3,"file":"schemaFromSimple.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaFromSimple.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 { unreachableCase, fail } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\tNodeKind,\n\ttype TreeNodeSchema,\n\ttype AllowedTypesFull,\n\tSchemaUpgrade,\n} from \"../core/index.js\";\nimport {\n\ttype FieldSchema,\n\ttype FieldSchemaAlpha,\n\tFieldKind,\n\ttype FieldProps,\n} from \"../fieldSchema.js\";\nimport type {\n\tSchemaType,\n\tSimpleAllowedTypeAttributes,\n\tSimpleFieldSchema,\n\tSimpleNodeSchema,\n\tSimpleTreeSchema,\n} from \"../simpleSchema.js\";\nimport type { TreeSchema } from \"../treeSchema.js\";\n\nimport { SchemaFactoryAlpha } from \"./schemaFactoryAlpha.js\";\n\nconst factory = new SchemaFactoryAlpha(undefined);\n\n/\n Create {@link FieldSchema} from a SimpleTreeSchema.\n * @remarks\n * Only use this API if hand written schema (produced using {@link SchemaFactory} cannot be provided.\n \n Using generated schema with schema aware APIs (designed to work with strongly typed schema) like {@link TreeViewConfiguration}\n * will produce a poor TypeScript typing experience which is subject to change.\n \n Editing through a view produced using this schema can easily violate invariants other users of the document might expect and must be done with great care.\n \n This API bakes in some arbitrary policy choices for how to handle data that is not included in the SimpleTreeSchema API, for example the value of `allowUnknownOptionalFields`.\n * If any particular choice is required for such cases, this API should not be used.\n \n @privateRemarks\n * TODO: Add the ability for consumers to inject custom policy.\n * For example, allow nodes with table schema identifiers to dispatch to `TableSchema` factory APIs.\n \n @alpha\n /\nexport function generateSchemaFromSimpleSchema(simple: SimpleTreeSchema): TreeSchema {\n\tconst context: Context = new Map(\n\t\t[...simple.definitions].map(\n\t\t\t([id, schema]): [string, () => TreeNodeSchema & SimpleNodeSchema<SchemaType.View>] => [\n\t\t\t\tid,\n\t\t\t\t// This relies on the caching in evaluateLazySchema so that it only runs once.\n\t\t\t\t() => generateNode(id, schema, context),\n\t\t\t],\n\t\t),\n\t);\n\tconst root = generateFieldSchema(simple.root, context, undefined);\n\tconst definitions = new Map<string, TreeNodeSchema & SimpleNodeSchema<SchemaType.View>>();\n\tfor (const [id, lazy] of context) {\n\t\tdefinitions.set(id, lazy());\n\t}\n\treturn {\n\t\troot,\n\t\tdefinitions,\n\t};\n}\n\ntype Context = ReadonlyMap<string, () => TreeNodeSchema & SimpleNodeSchema<SchemaType.View>>;\n\nfunction generateFieldSchema(\n\tsimple: SimpleFieldSchema,\n\tcontext: Context,\n\tstoredKey: string \| undefined,\n): FieldSchemaAlpha {\n\tconst allowed = generateAllowedTypes(simple.simpleAllowedTypes, context);\n\tconst props: Omit<FieldProps, \"defaultProvider\"> = {\n\t\tmetadata: simple.metadata,\n\t\tkey: storedKey,\n\t};\n\n\t// Using createFieldSchema could work, but would require setting up the default providers.\n\tswitch (simple.kind) {\n\t\tcase FieldKind.Identifier: {\n\t\t\treturn SchemaFactoryAlpha.identifier(props);\n\t\t}\n\t\tcase FieldKind.Optional: {\n\t\t\treturn SchemaFactoryAlpha.optional(allowed, props);\n\t\t}\n\t\tcase FieldKind.Required: {\n\t\t\treturn SchemaFactoryAlpha.required(allowed, props);\n\t\t}\n\t\tdefault: {\n\t\t\treturn unreachableCase(simple.kind);\n\t\t}\n\t}\n}\n\nfunction generateAllowedTypes(\n\tallowed: ReadonlyMap<string, SimpleAllowedTypeAttributes>,\n\tcontext: Context,\n): AllowedTypesFull {\n\tconst types = Array.from(allowed.entries(), ([id, attributes]) => {\n\t\tconst schema = context.get(id) ?? fail(0xb5a / Missing schema /);\n\t\treturn attributes.isStaged instanceof SchemaUpgrade ? factory.staged(schema) : schema;\n\t});\n\t// TODO: AB#53315: `AllowedTypesFullFromMixed` does not correctly handle the `(AnnotatedAllowedType \| LazyItem<TreeNodeSchema>)[]` case.\n\t// We have to cast here in order to produce an allowed types list that can be used in tree node factory methods (e.g., `SchemaFactoryAlpha.objectAlpha`).\n\treturn SchemaFactoryAlpha.types(types) as AllowedTypesFull;\n}\n\nfunction generateNode(\n\tid: string,\n\tschema: SimpleNodeSchema,\n\tcontext: Context,\n): TreeNodeSchema & SimpleNodeSchema<SchemaType.View> {\n\tswitch (schema.kind) {\n\t\tcase NodeKind.Object: {\n\t\t\tconst fields: Record<string, FieldSchema> = {};\n\t\t\tfor (const [key, field] of schema.fields) {\n\t\t\t\tfields[key] = generateFieldSchema(field, context, field.storedKey);\n\t\t\t}\n\t\t\t// Here allowUnknownOptionalFields is implicitly defaulting in the case where the input schema does not explicitly specify the value.\n\t\t\t// This is a subjective policy choice: users of this code are expected to handle what ever choice this code makes for cases like this.\n\t\t\treturn factory.objectAlpha(id, fields, {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t\tallowUnknownOptionalFields: schema.allowUnknownOptionalFields ?? false,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Array: {\n\t\t\treturn factory.arrayAlpha(id, generateAllowedTypes(schema.simpleAllowedTypes, context), {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Map: {\n\t\t\treturn factory.mapAlpha(id, generateAllowedTypes(schema.simpleAllowedTypes, context), {\n\t\t\t\tmetadata: schema.metadata,\n\t\t\t});\n\t\t}\n\t\tcase NodeKind.Record: {\n\t\t\treturn factory.recordAlpha(\n\t\t\t\tid,\n\t\t\t\tgenerateAllowedTypes(schema.simpleAllowedTypes, context),\n\t\t\t\t{ metadata: schema.metadata },\n\t\t\t);\n\t\t}\n\t\tcase NodeKind.Leaf: {\n\t\t\treturn (\n\t\t\t\tSchemaFactoryAlpha.leaves.find((leaf) => leaf.identifier === id) ??\n\t\t\t\tfail(0xb5b / Missing schema */)\n\t\t\t);\n\t\t}\n\t\tdefault: {\n\t\t\treturn unreachableCase(schema);\n\t\t}\n\t}\n}\n"]}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaStatics.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaStatics.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;~~AACpE~~,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAyC,MAAM,mBAAmB,CAAC;AACrF,OAAO,KAAK,EACX,UAAU,EACV,WAAW,EAEX,eAAe,EACf,gBAAgB,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EACN,YAAY,EAKZ,MAAM,sBAAsB,CAAC;~~AAC9B~~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"}
1	+ {"version":3,"file":"schemaStatics.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaStatics.ts"],"names":[],"mappings":"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"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaStatics.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaStatics.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAIH,sDAAqF;AASrF,4DAM8B;AA2I9B,MAAM,uBAAuB,GAAoB,IAAA,mCAAkB,EAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAE9E;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG;IAClC,MAAM,EAAE,gCAAY;IACpB,MAAM,EAAE,gCAAY;IACpB,OAAO,EAAE,iCAAa;IACtB,IAAI,EAAE,8BAAU;IAChB,MAAM,EAAE,gCAAY;IACpB,MAAM,EAAE,CAAC,gCAAY,EAAE,gCAAY,EAAE,iCAAa,EAAE,8BAAU,EAAE,gCAAY,CAAC;IAE7E,QAAQ,EAAE,CACT,CAAI,EACJ,KAAiE,EACN,EAAE;QAC7D,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE;YAC/C,eAAe,EAAE,uBAAuB;YACxC,GAAG,KAAK;SACR,CAAC,CAAC;IACJ,CAAC;IAED,QAAQ,EAAE,CACT,CAAI,EACJ,KAAiE,EACN,EAAE;QAC7D,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,iBAAiB,EAAE,CAIlB,CAAI,EACJ,KAAiE,EACA,EAAE;QACnE,OAAO,uBAAuB,CAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrD,eAAe,EAAE,uBAAuB;YACxC,GAAG,KAAK;SACR,CAAC,CAAC;IACJ,CAAC;IAED,iBAAiB,EAAE,CAIlB,CAAI,EACJ,KAAiE,EACA,EAAE;QACnE,OAAO,uBAAuB,CAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;CACgC,CAAC;AAEnC;;GAEG;AACU,QAAA,aAAa,GAAG;IAC5B,GAAG,2BAAmB;IACtB,UAAU,EAAE,CACX,KAA4D,EACmB,EAAE;QACjF,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,UAAU,EAAE,gCAAY,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;CACQ,CAAC;AAEX;;GAEG;AACH,SAAS,uBAAuB,CAK/B,IAAU,EACV,YAAmB,EACnB,KAAmC;IAEnC,kJAAkJ;IAClJ,OAAO,IAAA,kCAAiB,EACvB,IAAI,EACJ,YAA4C,EAC5C,KAAK,CACmD,CAAC;AAC3D,CAAC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport type { ImplicitAllowedTypes } from \"../core/index.js\";\nimport { FieldKind, getDefaultProvider, createFieldSchema } from \"../fieldSchema.js\";\nimport type {\n\tFieldProps,\n\tFieldSchema,\n\tDefaultProvider,\n\tFieldPropsAlpha,\n\tFieldSchemaAlpha,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema } from \"../leafNodeSchema.js\";\nimport {\n\tstringSchema,\n\tnumberSchema,\n\tbooleanSchema,\n\tnullSchema,\n\thandleSchema,\n} from \"../leafNodeSchema.js\";\nimport type { System_Unsafe, FieldSchemaAlphaUnsafe } from \"./typesUnsafe.js\";\n\n/\n Stateless APIs exposed via {@link SchemaFactory} as both instance properties and as statics.\n * @privateRemarks\n * We have no way to make linkable members which exist both as statics and instance properties since API-Extractor does not support this.\n * As a workaround, we have this type as a third place which can be linked.\n * @system @sealed @public\n /\nexport interface SchemaStatics {\n\t/\n\t {@link TreeNodeSchema} for holding a JavaScript `string`.\n\t \n\t @remarks\n\t * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.\n\t \n\t These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.\n\t * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t /\n\treadonly string: LeafSchema<\"string\", string>;\n\n\t/\n\t {@link TreeNodeSchema} for holding a JavaScript `number`.\n\t \n\t @remarks\n\t * The number is a {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format \| double-precision 64-bit binary format IEEE 754} value, however there are some exceptions:\n\t \n\t - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).\n\t \n\t - `-0` may be converted to `0` in some cases.\n\t \n\t These limitations match the limitations of JSON.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t /\n\treadonly number: LeafSchema<\"number\", number>;\n\n\t/\n\t {@link TreeNodeSchema} for holding a boolean.\n\t /\n\treadonly boolean: LeafSchema<\"boolean\", boolean>;\n\n\t/\n\t {@link TreeNodeSchema} for JavaScript `null`.\n\t \n\t @remarks\n\t * There are good {@link https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null \| reasons to avoid using null} in JavaScript, however sometimes it is desired.\n\t * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.\n\t * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.\n\t /\n\t// eslint-disable-next-line @rushstack/no-new-null\n\treadonly null: LeafSchema<\"null\", null>;\n\n\t/\n\t {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.\n\t /\n\treadonly handle: LeafSchema<\"handle\", IFluidHandle>;\n\n\t/\n\t {@link AllowedTypes} for holding any of the leaf types.\n\t /\n\treadonly leaves: readonly [\n\t\tSchemaStatics[\"string\"],\n\t\tSchemaStatics[\"number\"],\n\t\tSchemaStatics[\"boolean\"],\n\t\tSchemaStatics[\"null\"],\n\t\tSchemaStatics[\"handle\"],\n\t];\n\n\t/\n\t Make a field optional instead of the default, which is required.\n\t \n\t @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t \n\t @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n\t * See {@link FieldSchemaMetadata.custom}.\n\t /\n\treadonly optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => FieldSchema<FieldKind.Optional, T, TCustomMetadata>;\n\n\t/\n\t Make a field explicitly required.\n\t \n\t @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t \n\t @remarks\n\t * Fields are required by default, but this API can be used to make the required nature explicit in the schema,\n\t * and allows associating custom {@link FieldProps \| properties} with the field.\n\t \n\t @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n\t * See {@link FieldSchemaMetadata.custom}.\n\t /\n\treadonly required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => FieldSchema<FieldKind.Required, T, TCustomMetadata>;\n\n\t/\n\t {@link SchemaStatics.optional} 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 {@link SchemaStatics.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\treadonly optionalRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, T, TCustomMetadata>;\n\n\t/\n\t {@link SchemaStatics.required} 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 {@link SchemaStatics.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\treadonly requiredRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Required, T, TCustomMetadata>;\n}\n\nconst defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => []);\n\n/\n Implementation of {@link SchemaStatics}.\n * @remarks\n * Entries can use more specific types than {@link SchemaStatics} requires to be more useful for non-public consumers.\n * Additional non-public members are in {@link schemaStatics}.\n /\nexport const schemaStaticsStable = {\n\tstring: stringSchema,\n\tnumber: numberSchema,\n\tboolean: booleanSchema,\n\tnull: nullSchema,\n\thandle: handleSchema,\n\tleaves: [stringSchema, numberSchema, booleanSchema, nullSchema, handleSchema],\n\n\toptional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Optional, t, {\n\t\t\tdefaultProvider: defaultOptionalProvider,\n\t\t\t...props,\n\t\t});\n\t},\n\n\trequired: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Required, t, props);\n\t},\n\n\toptionalRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata> => {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Optional, t, {\n\t\t\tdefaultProvider: defaultOptionalProvider,\n\t\t\t...props,\n\t\t});\n\t},\n\n\trequiredRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata> => {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Required, t, props);\n\t},\n} as const satisfies SchemaStatics;\n\n/\n Unstable extensions to {@link schemaStaticsStable}.\n /\nexport const schemaStatics = {\n\t...schemaStaticsStable,\n\tidentifier: <const TCustomMetadata = unknown>(\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Identifier, typeof stringSchema, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Identifier, stringSchema, props);\n\t},\n} as const;\n\n/\n {@link Unenforced} version of {@link createFieldSchema}.\n */\nfunction createFieldSchemaUnsafe<\n\tKind extends FieldKind,\n\tTypes extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\tTCustomMetadata = unknown,\n>(\n\tkind: Kind,\n\tallowedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata> {\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 createFieldSchema(\n\t\tkind,\n\t\tallowedTypes as ImplicitAllowedTypes & Types,\n\t\tprops,\n\t) as FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata>;\n}\n"]}
1	+ {"version":3,"file":"schemaStatics.js","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaStatics.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAKH,sDAAqF;AASrF,4DAM8B;AA4I9B,MAAM,uBAAuB,GAAoB,IAAA,mCAAkB,EAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAE9E;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG;IAClC,MAAM,EAAE,gCAAY;IACpB,MAAM,EAAE,gCAAY;IACpB,OAAO,EAAE,iCAAa;IACtB,IAAI,EAAE,8BAAU;IAChB,MAAM,EAAE,gCAAY;IACpB,MAAM,EAAE,CAAC,gCAAY,EAAE,gCAAY,EAAE,iCAAa,EAAE,8BAAU,EAAE,gCAAY,CAAC;IAE7E,QAAQ,EAAE,CACT,CAAI,EACJ,KAAiE,EACN,EAAE;QAC7D,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE;YAC/C,eAAe,EAAE,uBAAuB;YACxC,GAAG,KAAK;SACR,CAAC,CAAC;IACJ,CAAC;IAED,QAAQ,EAAE,CACT,CAAI,EACJ,KAAiE,EACN,EAAE;QAC7D,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,iBAAiB,EAAE,CAIlB,CAAI,EACJ,KAAiE,EACA,EAAE;QACnE,OAAO,uBAAuB,CAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrD,eAAe,EAAE,uBAAuB;YACxC,GAAG,KAAK;SACR,CAAC,CAAC;IACJ,CAAC;IAED,iBAAiB,EAAE,CAIlB,CAAI,EACJ,KAAiE,EACA,EAAE;QACnE,OAAO,uBAAuB,CAAC,0BAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;CACgC,CAAC;AAEnC;;GAEG;AACU,QAAA,aAAa,GAAG;IAC5B,GAAG,2BAAmB;IACtB,UAAU,EAAE,CACX,KAA4D,EACmB,EAAE;QACjF,OAAO,IAAA,kCAAiB,EAAC,0BAAS,CAAC,UAAU,EAAE,gCAAY,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;CACQ,CAAC;AAEX;;GAEG;AACH,SAAS,uBAAuB,CAK/B,IAAU,EACV,YAAmB,EACnB,KAAmC;IAEnC,kJAAkJ;IAClJ,OAAO,IAAA,kCAAiB,EACvB,IAAI,EACJ,YAA4C,EAC5C,KAAK,CACmD,CAAC;AAC3D,CAAC","sourcesContent":["/!\n Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n /\n\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\n\nimport type { ImplicitAllowedTypes } from \"../core/index.js\";\nimport { FieldKind, getDefaultProvider, createFieldSchema } from \"../fieldSchema.js\";\nimport type {\n\tFieldProps,\n\tFieldSchema,\n\tDefaultProvider,\n\tFieldPropsAlpha,\n\tFieldSchemaAlpha,\n} from \"../fieldSchema.js\";\nimport type { LeafSchema } from \"../leafNodeSchema.js\";\nimport {\n\tstringSchema,\n\tnumberSchema,\n\tbooleanSchema,\n\tnullSchema,\n\thandleSchema,\n} from \"../leafNodeSchema.js\";\n\nimport type { System_Unsafe, FieldSchemaAlphaUnsafe } from \"./typesUnsafe.js\";\n\n/\n Stateless APIs exposed via {@link SchemaFactory} as both instance properties and as statics.\n * @privateRemarks\n * We have no way to make linkable members which exist both as statics and instance properties since API-Extractor does not support this.\n * As a workaround, we have this type as a third place which can be linked.\n * @system @sealed @public\n /\nexport interface SchemaStatics {\n\t/\n\t {@link TreeNodeSchema} for holding a JavaScript `string`.\n\t \n\t @remarks\n\t * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.\n\t \n\t These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.\n\t * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t /\n\treadonly string: LeafSchema<\"string\", string>;\n\n\t/\n\t {@link TreeNodeSchema} for holding a JavaScript `number`.\n\t \n\t @remarks\n\t * The number is a {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format \| double-precision 64-bit binary format IEEE 754} value, however there are some exceptions:\n\t \n\t - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).\n\t \n\t - `-0` may be converted to `0` in some cases.\n\t \n\t These limitations match the limitations of JSON.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t /\n\treadonly number: LeafSchema<\"number\", number>;\n\n\t/\n\t {@link TreeNodeSchema} for holding a boolean.\n\t /\n\treadonly boolean: LeafSchema<\"boolean\", boolean>;\n\n\t/\n\t {@link TreeNodeSchema} for JavaScript `null`.\n\t \n\t @remarks\n\t * There are good {@link https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null \| reasons to avoid using null} in JavaScript, however sometimes it is desired.\n\t * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.\n\t * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.\n\t /\n\t// eslint-disable-next-line @rushstack/no-new-null\n\treadonly null: LeafSchema<\"null\", null>;\n\n\t/\n\t {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.\n\t /\n\treadonly handle: LeafSchema<\"handle\", IFluidHandle>;\n\n\t/\n\t {@link AllowedTypes} for holding any of the leaf types.\n\t /\n\treadonly leaves: readonly [\n\t\tSchemaStatics[\"string\"],\n\t\tSchemaStatics[\"number\"],\n\t\tSchemaStatics[\"boolean\"],\n\t\tSchemaStatics[\"null\"],\n\t\tSchemaStatics[\"handle\"],\n\t];\n\n\t/\n\t Make a field optional instead of the default, which is required.\n\t \n\t @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t \n\t @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n\t * See {@link FieldSchemaMetadata.custom}.\n\t /\n\treadonly optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => FieldSchema<FieldKind.Optional, T, TCustomMetadata>;\n\n\t/\n\t Make a field explicitly required.\n\t \n\t @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t \n\t @remarks\n\t * Fields are required by default, but this API can be used to make the required nature explicit in the schema,\n\t * and allows associating custom {@link FieldProps \| properties} with the field.\n\t \n\t @typeParam TCustomMetadata - Custom metadata properties to associate with the field.\n\t * See {@link FieldSchemaMetadata.custom}.\n\t /\n\treadonly required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => FieldSchema<FieldKind.Required, T, TCustomMetadata>;\n\n\t/\n\t {@link SchemaStatics.optional} 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 {@link SchemaStatics.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\treadonly optionalRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, T, TCustomMetadata>;\n\n\t/\n\t {@link SchemaStatics.required} 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 {@link SchemaStatics.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t /\n\treadonly requiredRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t) => System_Unsafe.FieldSchemaUnsafe<FieldKind.Required, T, TCustomMetadata>;\n}\n\nconst defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => []);\n\n/\n Implementation of {@link SchemaStatics}.\n * @remarks\n * Entries can use more specific types than {@link SchemaStatics} requires to be more useful for non-public consumers.\n * Additional non-public members are in {@link schemaStatics}.\n /\nexport const schemaStaticsStable = {\n\tstring: stringSchema,\n\tnumber: numberSchema,\n\tboolean: booleanSchema,\n\tnull: nullSchema,\n\thandle: handleSchema,\n\tleaves: [stringSchema, numberSchema, booleanSchema, nullSchema, handleSchema],\n\n\toptional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Optional, t, {\n\t\t\tdefaultProvider: defaultOptionalProvider,\n\t\t\t...props,\n\t\t});\n\t},\n\n\trequired: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Required, t, props);\n\t},\n\n\toptionalRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata> => {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Optional, t, {\n\t\t\tdefaultProvider: defaultOptionalProvider,\n\t\t\t...props,\n\t\t});\n\t},\n\n\trequiredRecursive: <\n\t\tconst T extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\t\tconst TCustomMetadata = unknown,\n\t>(\n\t\tt: T,\n\t\tprops?: Omit<FieldPropsAlpha<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata> => {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Required, t, props);\n\t},\n} as const satisfies SchemaStatics;\n\n/\n Unstable extensions to {@link schemaStaticsStable}.\n /\nexport const schemaStatics = {\n\t...schemaStaticsStable,\n\tidentifier: <const TCustomMetadata = unknown>(\n\t\tprops?: Omit<FieldProps<TCustomMetadata>, \"defaultProvider\">,\n\t): FieldSchemaAlpha<FieldKind.Identifier, typeof stringSchema, TCustomMetadata> => {\n\t\treturn createFieldSchema(FieldKind.Identifier, stringSchema, props);\n\t},\n} as const;\n\n/\n {@link Unenforced} version of {@link createFieldSchema}.\n */\nfunction createFieldSchemaUnsafe<\n\tKind extends FieldKind,\n\tTypes extends System_Unsafe.ImplicitAllowedTypesUnsafe,\n\tTCustomMetadata = unknown,\n>(\n\tkind: Kind,\n\tallowedTypes: Types,\n\tprops?: FieldProps<TCustomMetadata>,\n): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata> {\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 createFieldSchema(\n\t\tkind,\n\t\tallowedTypes as ImplicitAllowedTypes & Types,\n\t\tprops,\n\t) as FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata>;\n}\n"]}

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

@@ -2,9 +2,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import { type FormatValidator } from "../../codec/index.js";
 import { type JsonCompatibleReadOnly } from "../../util/index.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
-import { type FormatValidator } from "../../codec/index.js";
 /**
  * Encodes the compatibility impacting subset of simple schema (view or stored) into a serializable format.
  *

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

	@@ -1 +1 @@
1	- {"version":3,"file":"simpleSchemaCodec.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/simpleSchemaCodec.ts"],"names":[],"mappings":"AAAA;;;GAGG;~~AAEH~~,OAAO,~~EAAe~~,KAAK,~~sBAAsB~~,~~EAAE~~,MAAM,~~qBAAqB~~,CAAC;~~AAE/E~~,OAAO,KAAK,~~EAUX~~,~~gBAAgB~~,~~EAChB,~~MAAM,~~oBAAoB~~,CAAC;~~AAM5B~~,OAAO,~~EAIN,~~KAAK,~~eAAe~~,~~EACpB~~,MAAM,~~sBAAsB~~,CAAC;~~AAE9B~~;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAChD,YAAY,EAAE,gBAAgB,GAC5B,sBAAsB,CAgBxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAChD,aAAa,EAAE,sBAAsB,EACrC,SAAS,CAAC,EAAE,eAAe,GACzB,gBAAgB,CAmBlB"}
1	+ {"version":3,"file":"simpleSchemaCodec.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/simpleSchemaCodec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAIN,KAAK,eAAe,EACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAe,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAG/E,OAAO,KAAK,EAUX,gBAAgB,EAChB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAChD,YAAY,EAAE,gBAAgB,GAC5B,sBAAsB,CAgBxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAChD,aAAa,EAAE,sBAAsB,EACrC,SAAS,CAAC,EAAE,eAAe,GACzB,gBAAgB,CAmBlB"}

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

@@ -28,12 +28,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeSchemaCompatibilitySnapshot = exports.encodeSchemaCompatibilitySnapshot = void 0;
-const index_js_1 = require("../../util/index.js");
 const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_2 = require("../core/index.js");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
+const index_js_1 = require("../../codec/index.js");
+const index_js_2 = require("../../util/index.js");
+const index_js_3 = require("../core/index.js");
 const Format = __importStar(require("../simpleSchemaFormatV1.js"));
-const index_js_3 = require("../../codec/index.js");
 /**
  * Encodes the compatibility impacting subset of simple schema (view or stored) into a serializable format.
  *
@@ -80,14 +80,14 @@ exports.encodeSchemaCompatibilitySnapshot = encodeSchemaCompatibilitySnapshot;
  * @alpha
  */
 function decodeSchemaCompatibilitySnapshot(encodedSchema, validator) {
-    const effectiveValidator = validator ?? index_js_3.FormatValidatorNoOp;
-    const compiledValidator = (0, index_js_3.extractJsonValidator)(effectiveValidator).compile(Format.SimpleTreeSchemaFormat);
+    const effectiveValidator = validator ?? index_js_1.FormatValidatorNoOp;
+    const compiledValidator = (0, index_js_1.extractJsonValidator)(effectiveValidator).compile(Format.SimpleTreeSchemaFormat);
     if (!compiledValidator.check(encodedSchema)) {
         throw new internal_2.UsageError("The provided simple schema is not valid according to the schema format.");
     }
     return {
         root: decodeSimpleFieldSchema(encodedSchema.root),
-        definitions: new Map((0, internal_1.transformMapValues)((0, index_js_1.objectToMap)(encodedSchema.definitions), (value, key) => {
+        definitions: new Map((0, internal_1.transformMapValues)((0, index_js_2.objectToMap)(encodedSchema.definitions), (value, key) => {
             return decodeNodeSchema(value);
         })),
     };
@@ -101,19 +101,19 @@ exports.decodeSchemaCompatibilitySnapshot = decodeSchemaCompatibilitySnapshot;
 function encodeNodeSchema(schema) {
     const kind = schema.kind;
     switch (kind) {
-        case index_js_2.NodeKind.Leaf: {
+        case index_js_3.NodeKind.Leaf: {
             return { leaf: encodeLeafNode(schema) };
         }
-        case index_js_2.NodeKind.Array: {
+        case index_js_3.NodeKind.Array: {
             return { array: encodeContainerNode(schema) };
         }
-        case index_js_2.NodeKind.Map: {
+        case index_js_3.NodeKind.Map: {
             return { map: encodeContainerNode(schema) };
         }
-        case index_js_2.NodeKind.Record: {
+        case index_js_3.NodeKind.Record: {
             return { record: encodeContainerNode(schema) };
         }
-        case index_js_2.NodeKind.Object: {
+        case index_js_3.NodeKind.Object: {
             return { object: encodeObjectNode(schema) };
         }
         default: {
@@ -152,7 +152,7 @@ function encodeContainerNode(schema) {
 function encodeSimpleAllowedTypes(simpleAllowedTypes) {
     const encodedAllowedTypes = {};
     for (const [identifier, attributes] of simpleAllowedTypes) {
-        const isStaged = attributes.isStaged instanceof index_js_2.SchemaUpgrade ? true : attributes.isStaged;
+        const isStaged = attributes.isStaged instanceof index_js_3.SchemaUpgrade ? true : attributes.isStaged;
         encodedAllowedTypes[identifier] = { isStaged };
     }
     return encodedAllowedTypes;
@@ -193,7 +193,7 @@ function encodeField(fieldSchema) {
         simpleAllowedTypes: encodeSimpleAllowedTypes(fieldSchema.simpleAllowedTypes),
     };
 }
-const decodeNodeSchemaDispatcher = new index_js_3.DiscriminatedUnionDispatcher({
+const decodeNodeSchemaDispatcher = new index_js_1.DiscriminatedUnionDispatcher({
     leaf: decodeLeafNode,
     array: decodeContainerNode,
     map: decodeContainerNode,
@@ -229,7 +229,7 @@ function decodeContainerNode(encodedContainerSchema) {
  */
 function decodeLeafNode(encodedLeafSchema) {
     return {
-        kind: index_js_2.NodeKind.Leaf,
+        kind: index_js_3.NodeKind.Leaf,
         leafKind: encodedLeafSchema.leafKind,
         // We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values.
         persistedMetadata: undefined,
@@ -243,7 +243,7 @@ function decodeLeafNode(encodedLeafSchema) {
  */
 function decodeObjectNode(encodedObjectSchema) {
     return {
-        kind: index_js_2.NodeKind.Object,
+        kind: index_js_3.NodeKind.Object,
         fields: decodeObjectFields(encodedObjectSchema.fields),
         // It is possible for allowUnknownOptionalFields to be undefined. This happens when serializing a Simple Schema derived
         // from a stored schema.
@@ -297,9 +297,9 @@ function decodeSimpleFieldSchema(encodedField) {
  * @returns A map of the decoded simple allowed types.
  */
 function decodeSimpleAllowedTypes(encodedAllowedTypes) {
-    const untypedMap = (0, index_js_1.objectToMap)(encodedAllowedTypes);
+    const untypedMap = (0, index_js_2.objectToMap)(encodedAllowedTypes);
     const simpleAllowedTypes = (0, internal_1.transformMapValues)(untypedMap, (value) => {
-        const isStaged = value.isStaged === true ? (0, index_js_2.createSchemaUpgrade)() : value.isStaged;
+        const isStaged = value.isStaged === true ? (0, index_js_3.createSchemaUpgrade)() : value.isStaged;
         return { isStaged };
     });
     return simpleAllowedTypes;