@fluidframework/tree 2.74.0-365691 → 2.74.0

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

@@ -1 +1 @@
-{"version":3,"file":"simpleSchema.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ValueSchema } from \"../core/index.js\";\nimport type { JsonCompatibleReadOnlyObject } from \"../util/index.js\";\nimport type { NodeKind, SchemaUpgrade, SimpleNodeSchemaBase } from \"./core/index.js\";\nimport type { FieldKind, FieldSchemaMetadata } from \"./fieldSchema.js\";\n\n/*\n * TODO:\n * - Customize their JSON serialization to use these formats or provide some other serialization scheme.\n */\n\n/**\n * A {@link SimpleNodeSchema} containing fields for alpha features.\n *\n * @system\n * @alpha\n * @sealed\n */\nexport interface SimpleNodeSchemaBaseAlpha<\n\tout TNodeKind extends NodeKind,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBase<TNodeKind, TCustomMetadata> {\n\t/**\n\t * Persisted metadata for this node schema.\n\t * @remarks\n\t * While this can be stored in the document, not all versions / configurations will do so.\n\t * Additionally, this is not part of {@link TreeView.compatibility|schema compatibility}, so different clients\n\t * (even within the same collaborative session) may see different `persistedMetadata` for the same node.\n\t * Specified using {@link NodeSchemaOptionsAlpha.persistedMetadata}.\n\t * @privateRemarks\n\t * How/when this gets updated in documents,\n\t * and how to read it from documents should be documented here when this feature is more mature and these questions have good answers.\n\t * If this does end up getting reflected in some compatibility value, that should also be documented.\n\t */\n\treadonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;\n}\n\n/**\n * {@link AllowedTypes} for a location in the tree, expressed for use in the Simple Schema layer of abstraction.\n *\n * @remarks\n * Refers to the types by identifier.\n * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n */\nexport type SimpleAllowedTypes = ReadonlyMap<string, SimpleAllowedTypeAttributes>;\n\n/**\n * A {@link SimpleNodeSchema} for an object node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleObjectNodeSchema<out TCustomMetadata = unknown>\n\textends SimpleNodeSchemaBaseAlpha<NodeKind.Object, TCustomMetadata> {\n\t/**\n\t * Schemas for each of the object's fields, keyed off of schema's keys.\n\t * @remarks\n\t * The keys are the property keys if known, otherwise they are the stored keys.\n\t * Use {@link SimpleObjectFieldSchema.storedKey} to get the stored key.\n\t * @privateRemarks\n\t * TODO: Provide and link a way to translate from stored keys to the property keys.\n\t * TODO: Consider adding `storedKeysToFields` or something similar to reduce confusion,\n\t * especially if/when TreeNodeSchema for objects provide more maps.\n\t */\n\treadonly fields: ReadonlyMap<string, SimpleObjectFieldSchema>;\n\n\t/**\n\t * Whether the object node allows unknown optional fields.\n\t *\n\t * @see {@link ObjectSchemaOptions.allowUnknownOptionalFields} for the API where this field is set as part of authoring a schema.\n\t *\n\t * @remarks Only populated for view schemas, undefined otherwise. Relevant for compatibility checking scenarios.\n\t */\n\treadonly allowUnknownOptionalFields: boolean | undefined;\n}\n\n/**\n * A {@link SimpleFieldSchema} for an {@link SimpleObjectNodeSchema} field.\n * @remarks\n * The only other case fields are uses in the root schema.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleObjectFieldSchema extends SimpleFieldSchema {\n\t/**\n\t * The stored key of the field.\n\t * @remarks\n\t * See {@link FieldProps.key} for more information.\n\t */\n\treadonly storedKey: string;\n}\n\n/**\n * A {@link SimpleNodeSchema} for an array node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleArrayNodeSchema<out TCustomMetadata = unknown>\n\textends SimpleNodeSchemaBaseAlpha<NodeKind.Array, TCustomMetadata> {\n\t/**\n\t * The types allowed in the array.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a map node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleMapNodeSchema<out TCustomMetadata = unknown>\n\textends SimpleNodeSchemaBaseAlpha<NodeKind.Map, TCustomMetadata> {\n\t/**\n\t * The types allowed as values in the map.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a map node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleRecordNodeSchema<out TCustomMetadata = unknown>\n\textends SimpleNodeSchemaBaseAlpha<NodeKind.Record, TCustomMetadata> {\n\t/**\n\t * The types allowed as values in the record.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a leaf node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleLeafNodeSchema extends SimpleNodeSchemaBaseAlpha<NodeKind.Leaf> {\n\t/**\n\t * The kind of leaf node.\n\t */\n\treadonly leafKind: ValueSchema;\n}\n\n/**\n * A simple, shallow representation of a schema for a node.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n *\n * Note that, as documented on {@link NodeKind}, more kinds of nodes may be added,\n * and therefore code should not assume that switching over all these cases can be done exhaustively.\n * @privateRemarks\n * Because of the above mentioned extensibility of node kinds, does it make sense to stabilize this?\n *\n * @alpha\n */\nexport type SimpleNodeSchema =\n\t| SimpleLeafNodeSchema\n\t| SimpleMapNodeSchema\n\t| SimpleArrayNodeSchema\n\t| SimpleObjectNodeSchema\n\t| SimpleRecordNodeSchema;\n\n/**\n * Information about allowed types under a field.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleAllowedTypeAttributes {\n\t/**\n\t * {@link SchemaUpgrade} if this schema is included as a {@link SchemaStaticsBeta.staged | staged} schema upgrade,\n\t * allowing the view schema be compatible with stored schema with (post upgrade) or without it (pre-upgrade).\n\t * New documents and schema upgrades will omit any staged schema.\n\t *\n\t * Undefined if derived from a stored schema.\n\t *\n\t * @privateRemarks\n\t * The false and undefined cases here are a bit odd.\n\t * This API should be reevaluated before stabilizing.\n\t */\n\treadonly isStaged: false | SchemaUpgrade | undefined;\n}\n\n/**\n * A simple, shallow representation of a schema for a field.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleFieldSchema {\n\t/**\n\t * The kind of tree field.\n\t */\n\treadonly kind: FieldKind;\n\n\t/**\n\t * Information about the allowed types under this field.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>;\n\n\t/**\n\t * {@inheritDoc FieldSchemaMetadata}\n\t */\n\treadonly metadata: FieldSchemaMetadata;\n\n\t/**\n\t * Persisted metadata for this field schema.\n\t * @remarks\n\t * Like {@link SimpleNodeSchemaBaseAlpha.persistedMetadata} but for fields.\n\t * Set via {@link FieldPropsAlpha.persistedMetadata}.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n}\n\n/**\n * A simplified representation of a schema for a tree.\n *\n * @remarks Contains the complete set of schema {@link SimpleTreeSchema.definitions} required to resolve references,\n * which are represented inline with identifiers.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleTreeSchema {\n\t/**\n\t * The tree field representing the root of the tree.\n\t */\n\treadonly root: SimpleFieldSchema;\n\n\t/**\n\t * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.root}.\n\t *\n\t * @remarks\n\t * The keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.\n\t *\n\t * Information about if a schema is {@link SchemaStaticsBeta.staged | staged} or not is not available as the \"Simple Schema\" layer of abstraction: they are included unconditionally.\n\t * Options for filtering out staged schemas from view schema are available in {@link extractPersistedSchema}.\n\t */\n\treadonly definitions: ReadonlyMap<string, SimpleNodeSchema>;\n}\n"]}
+{"version":3,"file":"simpleSchema.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAoOH;;;;GAIG;AACH,IAAY,UASX;AATD,WAAY,UAAU;IACrB;;OAEG;IACH,+CAAM,CAAA;IACN;;OAEG;IACH,2CAAI,CAAA;AACL,CAAC,EATW,UAAU,0BAAV,UAAU,QASrB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ValueSchema } from \"../core/index.js\";\nimport type { JsonCompatibleReadOnlyObject } from \"../util/index.js\";\nimport type { NodeKind, SchemaUpgrade, SimpleNodeSchemaBase } from \"./core/index.js\";\nimport type { FieldKind, FieldSchemaMetadata } from \"./fieldSchema.js\";\n\n/*\n * TODO:\n * - Customize their JSON serialization to use these formats or provide some other serialization scheme.\n */\n\n/**\n * A {@link SimpleNodeSchema} containing fields for alpha features.\n *\n * @system\n * @alpha\n * @sealed\n */\nexport interface SimpleNodeSchemaBaseAlpha<\n\tout Type extends SchemaType,\n\tout TNodeKind extends NodeKind,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBase<TNodeKind, TCustomMetadata> {\n\t/**\n\t * Persisted metadata for this node schema.\n\t * @remarks\n\t * While this can be stored in the document, not all versions / configurations will do so.\n\t * Additionally, this is not part of {@link TreeView.compatibility|schema compatibility}, so different clients\n\t * (even within the same collaborative session) may see different `persistedMetadata` for the same node.\n\t * Specified using {@link NodeSchemaOptionsAlpha.persistedMetadata}.\n\t * @privateRemarks\n\t * How/when this gets updated in documents,\n\t * and how to read it from documents should be documented here when this feature is more mature and these questions have good answers.\n\t * If this does end up getting reflected in some compatibility value, that should also be documented.\n\t */\n\treadonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;\n\n\t// This overrides the type from SimpleNodeSchemaBase to make it more specific. When stabilized, this should be moved to the base interface.\n\treadonly metadata: SimpleNodeSchemaBase<TNodeKind, TCustomMetadata>[\"metadata\"] &\n\t\t(Type extends SchemaType.View\n\t\t\t? unknown\n\t\t\t: { readonly custom?: undefined; readonly description?: undefined });\n}\n\n/**\n * {@link AllowedTypes} for a location in the tree, expressed for use in the Simple Schema layer of abstraction.\n *\n * @remarks\n * Refers to the types by identifier.\n * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n */\nexport type SimpleAllowedTypes<Type extends SchemaType = SchemaType> = ReadonlyMap<\n\tstring,\n\tSimpleAllowedTypeAttributes<Type>\n>;\n\n/**\n * A {@link SimpleNodeSchema} for an object node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleObjectNodeSchema<\n\tType extends SchemaType = SchemaType,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBaseAlpha<Type, NodeKind.Object, TCustomMetadata> {\n\t/**\n\t * Schemas for each of the object's fields, keyed off of schema's keys.\n\t * @remarks\n\t * The keys are the property keys if known, otherwise they are the stored keys.\n\t * Use {@link SimpleObjectFieldSchema.storedKey} to get the stored key.\n\t * @privateRemarks\n\t * TODO: Provide and link a way to translate from stored keys to the property keys.\n\t * TODO: Consider adding `storedKeysToFields` or something similar to reduce confusion,\n\t * especially if/when TreeNodeSchema for objects provide more maps.\n\t */\n\treadonly fields: ReadonlyMap<string, SimpleObjectFieldSchema<Type>>;\n\n\t/**\n\t * Whether the object node allows unknown optional fields.\n\t *\n\t * @see {@link ObjectSchemaOptions.allowUnknownOptionalFields} for the API where this field is set as part of authoring a schema.\n\t *\n\t * @remarks Only populated for view schemas, undefined otherwise. Relevant for compatibility checking scenarios.\n\t */\n\treadonly allowUnknownOptionalFields: Type extends SchemaType.View ? boolean : undefined;\n}\n\n/**\n * A {@link SimpleFieldSchema} for an {@link SimpleObjectNodeSchema} field.\n * @remarks\n * The only other case fields are uses in the root schema.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleObjectFieldSchema<Type extends SchemaType = SchemaType>\n\textends SimpleFieldSchema<Type> {\n\t/**\n\t * The stored key of the field.\n\t * @remarks\n\t * See {@link FieldProps.key} for more information.\n\t */\n\treadonly storedKey: string;\n}\n\n/**\n * A {@link SimpleNodeSchema} for an array node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleArrayNodeSchema<\n\tType extends SchemaType = SchemaType,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBaseAlpha<Type, NodeKind.Array, TCustomMetadata> {\n\t/**\n\t * The types allowed in the array.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes<Type>>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a map node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleMapNodeSchema<\n\tType extends SchemaType = SchemaType,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBaseAlpha<Type, NodeKind.Map, TCustomMetadata> {\n\t/**\n\t * The types allowed as values in the map.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes<Type>>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a map node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleRecordNodeSchema<\n\tType extends SchemaType = SchemaType,\n\tout TCustomMetadata = unknown,\n> extends SimpleNodeSchemaBaseAlpha<Type, NodeKind.Record, TCustomMetadata> {\n\t/**\n\t * The types allowed as values in the record.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes<Type>>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a leaf node.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleLeafNodeSchema<Type extends SchemaType = SchemaType>\n\textends SimpleNodeSchemaBaseAlpha<Type, NodeKind.Leaf> {\n\t/**\n\t * The kind of leaf node.\n\t */\n\treadonly leafKind: ValueSchema;\n}\n\n/**\n * A simple, shallow representation of a schema for a node.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n *\n * Note that, as documented on {@link NodeKind}, more kinds of nodes may be added,\n * and therefore code should not assume that switching over all these cases can be done exhaustively.\n * @privateRemarks\n * Because of the above mentioned extensibility of node kinds, does it make sense to stabilize this?\n *\n * @alpha\n */\nexport type SimpleNodeSchema<Type extends SchemaType = SchemaType> =\n\t| SimpleLeafNodeSchema<Type>\n\t| SimpleMapNodeSchema<Type>\n\t| SimpleArrayNodeSchema<Type>\n\t| SimpleObjectNodeSchema<Type>\n\t| SimpleRecordNodeSchema<Type>;\n\n/**\n * Information about allowed types under a field.\n *\n * @privateRemarks\n * Variance annotations should not be used to change type checking: they are only used by the compiler as an optimization hint.\n * However in this case, for unknown reasons, TypeScript makes this interface bi-variant without `out` on `Type`.\n * That is bad as it allows schema of unknown type to be used as stored or view without errors.\n * To mitigate this, `out` is added to make this interface properly covariant in `Type`.\n * This may not be robust if TypeScript checks this type structurally,\n * but whatever bug causes the bi-variant likely does not occur in that case anyway.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleAllowedTypeAttributes<out Type extends SchemaType = SchemaType> {\n\t/**\n\t * {@link SchemaUpgrade} if this schema is included as a {@link SchemaStaticsBeta.staged | staged} schema upgrade,\n\t * allowing the view schema be compatible with stored schema with (post upgrade) or without it (pre-upgrade).\n\t * New documents and schema upgrades will omit any staged schema.\n\t *\n\t * Undefined if derived from a stored schema.\n\t *\n\t * @privateRemarks\n\t * The false and undefined cases here are a bit odd.\n\t * This API should be reevaluated before stabilizing.\n\t */\n\treadonly isStaged: Type extends SchemaType.Stored ? undefined : false | SchemaUpgrade;\n}\n\n/**\n * The type of simple schema being represented.\n *\n * @alpha\n */\nexport enum SchemaType {\n\t/**\n\t * The schema is a stored schema, meaning it expresses exactly what could be validly persisted in a SharedTree.\n\t */\n\tStored,\n\t/**\n\t * The schema is a view schema, meaning it expresses how to view data which is using a compatible stored schema.\n\t */\n\tView,\n}\n/**\n * A simple, shallow representation of a schema for a field.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleFieldSchema<Type extends SchemaType = SchemaType> {\n\t/**\n\t * The kind of tree field.\n\t */\n\treadonly kind: FieldKind;\n\n\t/**\n\t * Information about the allowed types under this field.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes<Type>>;\n\n\t/**\n\t * Metadata for this field schema, see {@link FieldSchemaMetadata}.\n\t * @remarks\n\t * As this is the non-persisted portion of the metadata, it is forced to store only undefined in the `SchemaType.Stored` case.\n\t */\n\treadonly metadata: FieldSchemaMetadata &\n\t\t(Type extends SchemaType.View\n\t\t\t? unknown\n\t\t\t: { readonly custom?: undefined; readonly description?: undefined });\n\n\t/**\n\t * Persisted metadata for this field schema.\n\t * @remarks\n\t * Like {@link SimpleNodeSchemaBaseAlpha.persistedMetadata} but for fields.\n\t * Set via {@link FieldPropsAlpha.persistedMetadata}.\n\t */\n\treadonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;\n}\n\n/**\n * A simplified representation of a schema for a tree.\n *\n * @remarks Contains the complete set of schema {@link SimpleTreeSchema.definitions} required to resolve references,\n * which are represented inline with identifiers.\n *\n * @alpha\n * @sealed\n */\nexport interface SimpleTreeSchema<Type extends SchemaType = SchemaType> {\n\t/**\n\t * The tree field representing the root of the tree.\n\t */\n\treadonly root: SimpleFieldSchema<Type>;\n\t/**\n\t * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.root}.\n\t *\n\t * @remarks\n\t * The keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.\n\t *\n\t * Information about if a schema is {@link SchemaStaticsBeta.staged | staged} or not is not available as the \"Simple Schema\" layer of abstraction: they are included unconditionally.\n\t * Options for filtering out staged schemas from view schema are available in {@link extractPersistedSchema}.\n\t */\n\treadonly definitions: ReadonlyMap<string, SimpleNodeSchema<Type>>;\n}\n"]}

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

@@ -198,7 +198,7 @@ export declare const SimpleSchemaDefinitionsFormat: import("@sinclair/typebox").
 }>>;
 export type SimpleSchemaDefinitionsFormat = Static<typeof SimpleSchemaDefinitionsFormat>;
 /**
- * Persisted format for the entire tree schema in the simple schema format.
+ * Persisted format for the compatibility impacting subset of simple schema.
  * @see {@link SimpleTreeSchema}.
  */
 export declare const SimpleTreeSchemaFormat: import("@sinclair/typebox").TObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"simpleSchemaFormatV1.d.ts","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI1E;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAE5B,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;EAK7C,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,MAAM,CACrD,OAAO,iCAAiC,CACxC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;GAGpC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;EAMnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;EAOzC,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEzF;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;EAMvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAErF;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;EAMrC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEjF;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;EAMxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEvF;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;EAMtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;GAG1C,CAAC;AACF,MAAM,MAAM,8BAA8B,GAAG,MAAM,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE3F;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;EAOxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAErF;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGzC,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEzF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"simpleSchemaFormatV1.d.ts","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI1E;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAE5B,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;EAK7C,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,MAAM,CACrD,OAAO,iCAAiC,CACxC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;GAGpC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;EAMnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;EAOzC,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEzF;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;EAMvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAErF;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;EAMrC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEjF;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;EAMxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEvF;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;EAMtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;GAG1C,CAAC;AACF,MAAM,MAAM,8BAA8B,GAAG,MAAM,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE3F;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;EAOxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAErF;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGzC,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEzF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/simple-tree/simpleSchemaFormatV1.js

@@ -5,6 +5,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleTreeSchemaFormat = exports.SimpleSchemaDefinitionsFormat = exports.SimpleNodeSchemaUnionFormat = exports.SimpleObjectNodeSchemaFormat = exports.SimpleObjectFieldSchemasFormat = exports.SimpleLeafNodeSchemaFormat = exports.SimpleRecordNodeSchemaFormat = exports.SimpleMapNodeSchemaFormat = exports.SimpleArrayNodeSchemaFormat = exports.SimpleObjectFieldSchemaFormat = exports.SimpleFieldSchemaFormat = exports.SimpleAllowedTypesFormat = exports.SimpleAllowedTypeAttributesFormat = exports.SimpleSchemaFormatVersion = void 0;
+/*
+ * This file contains a format for serializing the compatibility impacting subset of simple schema.
+
+ * This format can be used for both view and stored simple schema.
+ * This only includes all parts of the schema that impact compatibility according to SchemaCompatibilityTester.
+ * It may not include some details which impact maintenance of application enforced invariants (like persisted metadata or logic in view schema).
+ */
 const typebox_1 = require("@sinclair/typebox");
 const noAdditionalProps = { additionalProperties: false };
 /**
@@ -104,7 +111,7 @@ exports.SimpleNodeSchemaUnionFormat = typebox_1.Type.Object({
  */
 exports.SimpleSchemaDefinitionsFormat = typebox_1.Type.Record(typebox_1.Type.String(), exports.SimpleNodeSchemaUnionFormat);
 /**
- * Persisted format for the entire tree schema in the simple schema format.
+ * Persisted format for the compatibility impacting subset of simple schema.
  * @see {@link SimpleTreeSchema}.
  */
 exports.SimpleTreeSchemaFormat = typebox_1.Type.Object({

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

@@ -1 +1 @@
-{"version":3,"file":"simpleSchemaFormatV1.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+CAA0E;AAE1E,MAAM,iBAAiB,GAAkB,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC;AAEzE;;GAEG;AACU,QAAA,yBAAyB,GAAG;IACxC,EAAE,EAAE,CAAC;CACI,CAAC;AAEX;;;GAGG;AACU,QAAA,iCAAiC,GAAG,cAAI,CAAC,MAAM,CAC3D;IACC,QAAQ,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,OAAO,EAAE,CAAC;CACvC,EACD,iBAAiB,CACjB,CAAC;AAMF;;;GAGG;AACU,QAAA,wBAAwB,GAAG,cAAI,CAAC,MAAM,CAClD,cAAI,CAAC,MAAM,EAAE,EACb,yCAAiC,CACjC,CAAC;AAGF;;;GAGG;AACU,QAAA,uBAAuB,GAAG,cAAI,CAAC,MAAM,CACjD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,kBAAkB,EAAE,gCAAwB;CAC5C,EACD,iBAAiB,CACjB,CAAC;AAGF;;;GAGG;AACU,QAAA,6BAA6B,GAAG,cAAI,CAAC,MAAM,CACvD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,kBAAkB,EAAE,gCAAwB;IAC5C,SAAS,EAAE,cAAI,CAAC,MAAM,EAAE;CACxB,EACD,iBAAiB,CACjB,CAAC;AAGF;;;GAGG;AACU,QAAA,2BAA2B,GAAG,cAAI,CAAC,MAAM,CACrD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,kBAAkB,EAAE,gCAAwB;CAC5C,EACD,iBAAiB,CACjB,CAAC;AAGF;;;GAGG;AACU,QAAA,yBAAyB,GAAG,cAAI,CAAC,MAAM,CACnD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,kBAAkB,EAAE,gCAAwB;CAC5C,EACD,iBAAiB,CACjB,CAAC;AAGF;;;GAGG;AACU,QAAA,4BAA4B,GAAG,cAAI,CAAC,MAAM,CACtD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,kBAAkB,EAAE,gCAAwB;CAC5C,EACD,iBAAiB,CACjB,CAAC;AAGF;;;GAGG;AACU,QAAA,0BAA0B,GAAG,cAAI,CAAC,MAAM,CACpD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,QAAQ,EAAE,cAAI,CAAC,OAAO,EAAE;CACxB,EACD,iBAAiB,CACjB,CAAC;AAGF;;GAEG;AACU,QAAA,8BAA8B,GAAG,cAAI,CAAC,MAAM,CACxD,cAAI,CAAC,MAAM,EAAE,EACb,qCAA6B,CAC7B,CAAC;AAGF;;;GAGG;AACU,QAAA,4BAA4B,GAAG,cAAI,CAAC,MAAM,CACtD;IACC,IAAI,EAAE,cAAI,CAAC,OAAO,EAAE;IACpB,MAAM,EAAE,sCAA8B;IACtC,0BAA0B,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,OAAO,EAAE,CAAC;CACzD,EACD,iBAAiB,CACjB,CAAC;AAGF;;;;GAIG;AACU,QAAA,2BAA2B,GAAG,cAAI,CAAC,MAAM,CAAC;IACtD,KAAK,EAAE,cAAI,CAAC,QAAQ,CAAC,mCAA2B,CAAC;IACjD,GAAG,EAAE,cAAI,CAAC,QAAQ,CAAC,iCAAyB,CAAC;IAC7C,MAAM,EAAE,cAAI,CAAC,QAAQ,CAAC,oCAA4B,CAAC;IACnD,IAAI,EAAE,cAAI,CAAC,QAAQ,CAAC,kCAA0B,CAAC;IAC/C,MAAM,EAAE,cAAI,CAAC,QAAQ,CAAC,oCAA4B,CAAC;CACnD,CAAC,CAAC;AAGH;;GAEG;AACU,QAAA,6BAA6B,GAAG,cAAI,CAAC,MAAM,CACvD,cAAI,CAAC,MAAM,EAAE,EACb,mCAA2B,CAC3B,CAAC;AAGF;;;GAGG;AACU,QAAA,sBAAsB,GAAG,cAAI,CAAC,MAAM,CAChD;IACC,OAAO,EAAE,cAAI,CAAC,OAAO,CAAC,iCAAyB,CAAC,EAAE,CAAC;IACnD,IAAI,EAAE,+BAAuB;IAC7B,WAAW,EAAE,qCAA6B;CAC1C,EACD,iBAAiB,CACjB,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Type, type ObjectOptions, type Static } from \"@sinclair/typebox\";\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\n/**\n * The format version for the schema.\n */\nexport const SimpleSchemaFormatVersion = {\n\tv1: 1,\n} as const;\n\n/**\n * The allowed types and their attributes in the simple schema format.\n * @see {@link SimpleAllowedTypes}.\n */\nexport const SimpleAllowedTypeAttributesFormat = Type.Object(\n\t{\n\t\tisStaged: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\n\nexport type SimpleAllowedTypeAttributesFormat = Static<\n\ttypeof SimpleAllowedTypeAttributesFormat\n>;\n\n/**\n * A set of allowed types in the simple schema format.\n * The keys are the type identifiers, and the values are their attributes.\n */\nexport const SimpleAllowedTypesFormat = Type.Record(\n\tType.String(),\n\tSimpleAllowedTypeAttributesFormat,\n);\nexport type SimpleAllowedTypesFormat = Static<typeof SimpleAllowedTypesFormat>;\n\n/**\n * Persisted format for a field schema in the simple schema format.\n * @see {@link SimpleFieldSchema}.\n */\nexport const SimpleFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleFieldSchemaFormat = Static<typeof SimpleFieldSchemaFormat>;\n\n/**\n * Persisted format for an object field schema in the simple schema format.\n * @see {@link SimpleObjectFieldSchema}.\n */\nexport const SimpleObjectFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t\tstoredKey: Type.String(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectFieldSchemaFormat = Static<typeof SimpleObjectFieldSchemaFormat>;\n\n/**\n * Persisted format for an array node schema in the simple schema format.\n * @see {@link SimpleArrayNodeSchema}.\n */\nexport const SimpleArrayNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleArrayNodeSchemaFormat = Static<typeof SimpleArrayNodeSchemaFormat>;\n\n/**\n * Persisted format for a map node schema in the simple schema format.\n * @see {@link SimpleMapNodeSchema}.\n */\nexport const SimpleMapNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleMapNodeSchemaFormat = Static<typeof SimpleMapNodeSchemaFormat>;\n\n/**\n * Persisted format for a record node schema in the simple schema format.\n * @see {@link SimpleRecordNodeSchema}.\n */\nexport const SimpleRecordNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleRecordNodeSchemaFormat = Static<typeof SimpleRecordNodeSchemaFormat>;\n\n/**\n * Persisted format for a leaf node schema in the simple schema format.\n * @see {@link SimpleLeafNodeSchema}.\n */\nexport const SimpleLeafNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tleafKind: Type.Integer(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleLeafNodeSchemaFormat = Static<typeof SimpleLeafNodeSchemaFormat>;\n\n/**\n * Persisted format for the field schemas of an object node in the simple schema format.\n */\nexport const SimpleObjectFieldSchemasFormat = Type.Record(\n\tType.String(),\n\tSimpleObjectFieldSchemaFormat,\n);\nexport type SimpleObjectFieldSchemasFormat = Static<typeof SimpleObjectFieldSchemasFormat>;\n\n/**\n * Persisted format for an object node schema in the simple schema format.\n * @see {@link SimpleObjectNodeSchema}.\n */\nexport const SimpleObjectNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tfields: SimpleObjectFieldSchemasFormat,\n\t\tallowUnknownOptionalFields: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectNodeSchemaFormat = Static<typeof SimpleObjectNodeSchemaFormat>;\n\n/**\n * Discriminated union of all possible node schemas.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const SimpleNodeSchemaUnionFormat = Type.Object({\n\tarray: Type.Optional(SimpleArrayNodeSchemaFormat),\n\tmap: Type.Optional(SimpleMapNodeSchemaFormat),\n\trecord: Type.Optional(SimpleRecordNodeSchemaFormat),\n\tleaf: Type.Optional(SimpleLeafNodeSchemaFormat),\n\tobject: Type.Optional(SimpleObjectNodeSchemaFormat),\n});\nexport type SimpleNodeSchemaUnionFormat = Static<typeof SimpleNodeSchemaUnionFormat>;\n\n/**\n * Helper type for the schema definitions map in the persisted format.\n */\nexport const SimpleSchemaDefinitionsFormat = Type.Record(\n\tType.String(),\n\tSimpleNodeSchemaUnionFormat,\n);\nexport type SimpleSchemaDefinitionsFormat = Static<typeof SimpleSchemaDefinitionsFormat>;\n\n/**\n * Persisted format for the entire tree schema in the simple schema format.\n * @see {@link SimpleTreeSchema}.\n */\nexport const SimpleTreeSchemaFormat = Type.Object(\n\t{\n\t\tversion: Type.Literal(SimpleSchemaFormatVersion.v1),\n\t\troot: SimpleFieldSchemaFormat,\n\t\tdefinitions: SimpleSchemaDefinitionsFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleTreeSchemaFormat = Static<typeof SimpleTreeSchemaFormat>;\n"]}
+{"version":3,"file":"simpleSchemaFormatV1.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.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\n/*\n * This file contains a format for serializing the compatibility impacting subset of simple schema.\n\n * This format can be used for both view and stored simple schema.\n * This only includes all parts of the schema that impact compatibility according to SchemaCompatibilityTester.\n * It may not include some details which impact maintenance of application enforced invariants (like persisted metadata or logic in view schema).\n */\n\nimport { Type, type ObjectOptions, type Static } from \"@sinclair/typebox\";\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\n/**\n * The format version for the schema.\n */\nexport const SimpleSchemaFormatVersion = {\n\tv1: 1,\n} as const;\n\n/**\n * The allowed types and their attributes in the simple schema format.\n * @see {@link SimpleAllowedTypes}.\n */\nexport const SimpleAllowedTypeAttributesFormat = Type.Object(\n\t{\n\t\tisStaged: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\n\nexport type SimpleAllowedTypeAttributesFormat = Static<\n\ttypeof SimpleAllowedTypeAttributesFormat\n>;\n\n/**\n * A set of allowed types in the simple schema format.\n * The keys are the type identifiers, and the values are their attributes.\n */\nexport const SimpleAllowedTypesFormat = Type.Record(\n\tType.String(),\n\tSimpleAllowedTypeAttributesFormat,\n);\nexport type SimpleAllowedTypesFormat = Static<typeof SimpleAllowedTypesFormat>;\n\n/**\n * Persisted format for a field schema in the simple schema format.\n * @see {@link SimpleFieldSchema}.\n */\nexport const SimpleFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleFieldSchemaFormat = Static<typeof SimpleFieldSchemaFormat>;\n\n/**\n * Persisted format for an object field schema in the simple schema format.\n * @see {@link SimpleObjectFieldSchema}.\n */\nexport const SimpleObjectFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t\tstoredKey: Type.String(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectFieldSchemaFormat = Static<typeof SimpleObjectFieldSchemaFormat>;\n\n/**\n * Persisted format for an array node schema in the simple schema format.\n * @see {@link SimpleArrayNodeSchema}.\n */\nexport const SimpleArrayNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleArrayNodeSchemaFormat = Static<typeof SimpleArrayNodeSchemaFormat>;\n\n/**\n * Persisted format for a map node schema in the simple schema format.\n * @see {@link SimpleMapNodeSchema}.\n */\nexport const SimpleMapNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleMapNodeSchemaFormat = Static<typeof SimpleMapNodeSchemaFormat>;\n\n/**\n * Persisted format for a record node schema in the simple schema format.\n * @see {@link SimpleRecordNodeSchema}.\n */\nexport const SimpleRecordNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleRecordNodeSchemaFormat = Static<typeof SimpleRecordNodeSchemaFormat>;\n\n/**\n * Persisted format for a leaf node schema in the simple schema format.\n * @see {@link SimpleLeafNodeSchema}.\n */\nexport const SimpleLeafNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tleafKind: Type.Integer(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleLeafNodeSchemaFormat = Static<typeof SimpleLeafNodeSchemaFormat>;\n\n/**\n * Persisted format for the field schemas of an object node in the simple schema format.\n */\nexport const SimpleObjectFieldSchemasFormat = Type.Record(\n\tType.String(),\n\tSimpleObjectFieldSchemaFormat,\n);\nexport type SimpleObjectFieldSchemasFormat = Static<typeof SimpleObjectFieldSchemasFormat>;\n\n/**\n * Persisted format for an object node schema in the simple schema format.\n * @see {@link SimpleObjectNodeSchema}.\n */\nexport const SimpleObjectNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tfields: SimpleObjectFieldSchemasFormat,\n\t\tallowUnknownOptionalFields: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectNodeSchemaFormat = Static<typeof SimpleObjectNodeSchemaFormat>;\n\n/**\n * Discriminated union of all possible node schemas.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const SimpleNodeSchemaUnionFormat = Type.Object({\n\tarray: Type.Optional(SimpleArrayNodeSchemaFormat),\n\tmap: Type.Optional(SimpleMapNodeSchemaFormat),\n\trecord: Type.Optional(SimpleRecordNodeSchemaFormat),\n\tleaf: Type.Optional(SimpleLeafNodeSchemaFormat),\n\tobject: Type.Optional(SimpleObjectNodeSchemaFormat),\n});\nexport type SimpleNodeSchemaUnionFormat = Static<typeof SimpleNodeSchemaUnionFormat>;\n\n/**\n * Helper type for the schema definitions map in the persisted format.\n */\nexport const SimpleSchemaDefinitionsFormat = Type.Record(\n\tType.String(),\n\tSimpleNodeSchemaUnionFormat,\n);\nexport type SimpleSchemaDefinitionsFormat = Static<typeof SimpleSchemaDefinitionsFormat>;\n\n/**\n * Persisted format for the compatibility impacting subset of simple schema.\n * @see {@link SimpleTreeSchema}.\n */\nexport const SimpleTreeSchemaFormat = Type.Object(\n\t{\n\t\tversion: Type.Literal(SimpleSchemaFormatVersion.v1),\n\t\troot: SimpleFieldSchemaFormat,\n\t\tdefinitions: SimpleSchemaDefinitionsFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleTreeSchemaFormat = Static<typeof SimpleTreeSchemaFormat>;\n"]}

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

@@ -2,14 +2,31 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { ObjectNodeStoredSchema, type TreeFieldStoredSchema, type TreeNodeStoredSchema, type TreeStoredSchema } from "../core/index.js";
+import { type TreeFieldStoredSchema, type TreeNodeStoredSchema, type TreeStoredSchema } from "../core/index.js";
 import { type FlexFieldKind } from "../feature-libraries/index.js";
-import { type JsonCompatibleReadOnlyObject } from "../util/index.js";
-import { type StoredFromViewSchemaGenerationOptions, type StoredSchemaGenerationOptions } from "./core/index.js";
+import { ExpectStored, Unchanged, type SimpleSchemaTransformationOptions, type StoredFromViewSchemaGenerationOptions } from "./core/index.js";
 import { FieldKind, type ImplicitFieldSchema } from "./fieldSchema.js";
-import type { SimpleAllowedTypes, SimpleFieldSchema, SimpleNodeSchema, SimpleTreeSchema } from "./simpleSchema.js";
-export declare const restrictiveStoredSchemaGenerationOptions: StoredSchemaGenerationOptions;
-export declare const permissiveStoredSchemaGenerationOptions: StoredSchemaGenerationOptions;
+import type { SchemaType, SimpleAllowedTypes, SimpleFieldSchema, SimpleNodeSchema, SimpleTreeSchema } from "./simpleSchema.js";
+/**
+ * Maximally restrictive transformation of a view to stored schema.
+ * @remarks
+ * This should only be used when the intent is to produce a stored schema is as restrictive as possible while still being compatible with the input view schema.
+ * This is typically used for cases where backwards compatibility with past versions of an application is required, like {@link toUpgradeSchema} or {@link toInitialSchema}.
+ */
+export declare const restrictiveStoredSchemaGenerationOptions: StoredFromViewSchemaGenerationOptions;
+/**
+ * Maximally permissive transformation of a view to stored schema.
+ * @remarks
+ * This should only be used when the intent is to produce a stored schema which allows as much as possible while still being compatible with the input view schema.
+ * This is typically used for cases where forwards compatibility with future versions of an application is required, like {@link toUnhydratedSchema}.
+ *
+ * This is unable to include unknown optional fields in the output, which makes it not truly maximally permissive.
+ *
+ * TODO: {@link StoredFromViewSchemaGenerationOptions} could be updated to allow a way to inject extra optional fields.
+ * If done, then this could take in an existing stored schema, and attempt to generate a valid superset.
+ * This could be useful to use as the schema for unhydrated content cloned from hydrated content.
+ */
+export declare const permissiveStoredSchemaGenerationOptions: StoredFromViewSchemaGenerationOptions;
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} for use in schema upgrades.
  *
@@ -41,7 +58,23 @@ export declare const toUnhydratedSchema: StoredFromViewSchemaGenerationOptions;
  * @throws
  * Throws a `UsageError` if multiple schemas are encountered with the same identifier.
  */
-export declare function toStoredSchema(root: ImplicitFieldSchema, options: StoredSchemaGenerationOptions): TreeStoredSchema;
+export declare function toStoredSchema(root: ImplicitFieldSchema, options: StoredFromViewSchemaGenerationOptions): TreeStoredSchema;
+/**
+ * Converts a {@link SimpleTreeSchema} from `SchemaType.View` to `SchemaType.Stored`.
+ */
+export declare function transformSimpleSchema(schema: SimpleTreeSchema<SchemaType.View>, options: StoredFromViewSchemaGenerationOptions): SimpleTreeSchema<SchemaType.Stored>;
+/**
+ * Copies a `SchemaType.Stored` {@link SimpleTreeSchema}.
+ */
+export declare function transformSimpleSchema(schema: SimpleTreeSchema<SchemaType.Stored>, options: ExpectStored): SimpleTreeSchema<SchemaType.Stored>;
+/**
+ * Copies a {@link SimpleTreeSchema}.
+ */
+export declare function transformSimpleSchema<T extends SchemaType>(schema: SimpleTreeSchema<T>, options: Unchanged): SimpleTreeSchema<T>;
+/**
+ * Converts a {@link SimpleTreeSchema}.
+ */
+export declare function transformSimpleSchema(schema: SimpleTreeSchema, options: SimpleSchemaTransformationOptions): SimpleTreeSchema;
 /**
  * Convert a {@link SimpleTreeSchema} for a stored schema into a {@link TreeStoredSchema}.
  * @remarks
@@ -50,11 +83,11 @@ export declare function toStoredSchema(root: ImplicitFieldSchema, options: Store
  * To correctly support view schema here, this would need to filter out unreferenced schema after excluding staged schema.
  * @see {@link ExpectStored}.
  */
-export declare function simpleStoredSchemaToStoredSchema(treeSchema: SimpleTreeSchema): TreeStoredSchema;
+export declare function simpleStoredSchemaToStoredSchema(treeSchema: SimpleTreeSchema<SchemaType.Stored>): TreeStoredSchema;
 /**
  * Convert a {@link SimpleFieldSchema} into a {@link TreeFieldStoredSchema}.
  */
-export declare function convertField(schema: SimpleFieldSchema, options: StoredSchemaGenerationOptions): TreeFieldStoredSchema;
+export declare function convertField(schema: SimpleFieldSchema<SchemaType.Stored>): TreeFieldStoredSchema;
 /**
  * A map that converts {@link FieldKind} to {@link FlexFieldKind}.
  */
@@ -64,6 +97,20 @@ export declare const convertFieldKind: ReadonlyMap<FieldKind, FlexFieldKind>;
  * @privateRemarks
  * TODO: Persist node metadata once schema FormatV2 is supported.
  */
-export declare function getStoredSchema(schema: SimpleNodeSchema, options: StoredSchemaGenerationOptions): TreeNodeStoredSchema;
-export declare function arrayNodeStoredSchema(schema: SimpleAllowedTypes, options: StoredSchemaGenerationOptions, persistedMetadata: JsonCompatibleReadOnlyObject | undefined): ObjectNodeStoredSchema;
+export declare function getStoredSchema(schema: SimpleNodeSchema<SchemaType.Stored>): TreeNodeStoredSchema;
+/**
+ * Converts a {@link SimpleNodeSchema} from view to stored.
+ */
+export declare function transformSimpleNodeSchema(schema: SimpleNodeSchema<SchemaType.View>, options: StoredFromViewSchemaGenerationOptions): SimpleNodeSchema<SchemaType.Stored>;
+/**
+ * Converts a {@link SimpleNodeSchema}.
+ */
+export declare function transformSimpleNodeSchema(schema: SimpleNodeSchema, options: SimpleSchemaTransformationOptions): SimpleNodeSchema;
+/**
+ * Converts a {@link SimpleAllowedTypes} to a stored schema.
+ * @param schema - The schema to convert.
+ * @param options - The options to use for filtering.
+ * @returns The converted stored schema.
+ */
+export declare function filterAllowedTypes(schema: SimpleAllowedTypes, options: SimpleSchemaTransformationOptions): SimpleAllowedTypes;
 //# sourceMappingURL=toStoredSchema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toStoredSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/toStoredSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAIN,sBAAsB,EAGtB,KAAK,qBAAqB,EAE1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,EAAsB,KAAK,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAEzF,OAAO,EAMN,KAAK,qCAAqC,EAC1C,KAAK,6BAA6B,EAClC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAwB,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,KAAK,EACX,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,MAAM,mBAAmB,CAAC;AAQ3B,eAAO,MAAM,wCAAwC,EAAE,6BAEtD,CAAC;AAEF,eAAO,MAAM,uCAAuC,EAAE,6BAErD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,gBAAgB,CAE3E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,gBAAgB,CAE3E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,uCAA0C,CAAC;AAE1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,6BAA6B,GACpC,gBAAgB,CAoClB;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC/C,UAAU,EAAE,gBAAgB,GAC1B,gBAAgB,CAQlB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,6BAA6B,GACpC,qBAAqB,CAKvB;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,SAAS,EAAE,aAAa,CAOjE,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,6BAA6B,GACpC,oBAAoB,CAqCtB;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,6BAA6B,EACtC,iBAAiB,EAAE,4BAA4B,GAAG,SAAS,GACzD,sBAAsB,CAQxB"}
+{"version":3,"file":"toStoredSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/toStoredSchema.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/toStoredSchema.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayNodeStoredSchema = exports.getStoredSchema = exports.convertFieldKind = exports.convertField = exports.simpleStoredSchemaToStoredSchema = exports.toStoredSchema = exports.toUnhydratedSchema = exports.toInitialSchema = exports.toUpgradeSchema = exports.permissiveStoredSchemaGenerationOptions = exports.restrictiveStoredSchemaGenerationOptions = void 0;
+exports.filterAllowedTypes = exports.transformSimpleNodeSchema = exports.getStoredSchema = exports.convertFieldKind = exports.convertField = exports.simpleStoredSchemaToStoredSchema = exports.transformSimpleSchema = exports.toStoredSchema = exports.toUnhydratedSchema = exports.toInitialSchema = exports.toUpgradeSchema = exports.permissiveStoredSchemaGenerationOptions = exports.restrictiveStoredSchemaGenerationOptions = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../core/index.js");
@@ -12,11 +12,33 @@ const index_js_2 = require("../feature-libraries/index.js");
 const index_js_3 = require("../util/index.js");
 const index_js_4 = require("./core/index.js");
 const fieldSchema_js_1 = require("./fieldSchema.js");
-const walkFieldSchema_js_1 = require("./walkFieldSchema.js");
+const treeSchema_js_1 = require("./treeSchema.js");
+// TODO: this file, src/simple-tree/api/storedSchema.ts and src/simple-tree/core/toStored.ts should be refactored to group the logic more logically.
+// The content of src/simple-tree/api/storedSchema.ts should probably removed from the API surface, replaced by simple schema snapshotting APIs.
+// The logic from this file for converting stored-simple-schema to the persisted format can be moved to its own file.
+// The simple-schema related logic from this file and src/simple-tree/core/toStored.ts can be unified and `toStoredSchema` and its other ImplicitFieldSchema consuming variants should probably be removed in favor of acting on TreeSchema and SimpleTreeSchema directly.
 const viewToStoredCache = new WeakMap();
+/**
+ * Maximally restrictive transformation of a view to stored schema.
+ * @remarks
+ * This should only be used when the intent is to produce a stored schema is as restrictive as possible while still being compatible with the input view schema.
+ * This is typically used for cases where backwards compatibility with past versions of an application is required, like {@link toUpgradeSchema} or {@link toInitialSchema}.
+ */
 exports.restrictiveStoredSchemaGenerationOptions = {
     includeStaged: () => false,
 };
+/**
+ * Maximally permissive transformation of a view to stored schema.
+ * @remarks
+ * This should only be used when the intent is to produce a stored schema which allows as much as possible while still being compatible with the input view schema.
+ * This is typically used for cases where forwards compatibility with future versions of an application is required, like {@link toUnhydratedSchema}.
+ *
+ * This is unable to include unknown optional fields in the output, which makes it not truly maximally permissive.
+ *
+ * TODO: {@link StoredFromViewSchemaGenerationOptions} could be updated to allow a way to inject extra optional fields.
+ * If done, then this could take in an existing stored schema, and attempt to generate a valid superset.
+ * This could be useful to use as the schema for unhydrated content cloned from hydrated content.
+ */
 exports.permissiveStoredSchemaGenerationOptions = {
     includeStaged: () => true,
 };
@@ -60,26 +82,51 @@ exports.toUnhydratedSchema = exports.permissiveStoredSchemaGenerationOptions;
 function toStoredSchema(root, options) {
     const cache = (0, index_js_3.getOrCreate)(viewToStoredCache, options, () => new WeakMap());
     return (0, index_js_3.getOrCreate)(cache, root, () => {
-        const normalized = (0, fieldSchema_js_1.normalizeFieldSchema)(root);
-        const nodeSchema = new Map();
-        (0, walkFieldSchema_js_1.walkFieldSchema)(normalized, {
-            node(schema) {
-                if (nodeSchema.has((0, index_js_3.brand)(schema.identifier))) {
-                    // Use JSON.stringify to quote and escape identifier string.
-                    throw new internal_2.UsageError(`Multiple schema encountered with the identifier ${JSON.stringify(schema.identifier)}. Remove or rename them to avoid the collision.`);
-                }
-                nodeSchema.set((0, index_js_3.brand)(schema.identifier), getStoredSchema(schema, options));
-            },
-            allowedTypeFilter: (allowedType) => (0, index_js_4.allowedTypeFilter)({ isStaged: allowedType.metadata.stagedSchemaUpgrade ?? false }, options),
-        });
-        const result = {
-            nodeSchema,
-            rootFieldSchema: convertField(normalized, options),
-        };
-        return result;
+        const treeSchema = (0, treeSchema_js_1.createTreeSchema)((0, fieldSchema_js_1.normalizeFieldSchema)(root));
+        const simpleSchema = transformSimpleSchema(treeSchema, options);
+        return simpleStoredSchemaToStoredSchema(simpleSchema);
     });
 }
 exports.toStoredSchema = toStoredSchema;
+/**
+ * TODO:#38722 When runtime schema upgrades are implemented, this will need to be updated to check if
+ * a staged allowed type has been upgraded and if so, include it in the conversion.
+ */
+function transformSimpleSchema(schema, options) {
+    const simpleNodeSchema = new Map();
+    const root = filterFieldAllowedTypes(schema.root, options);
+    const queue = Array.from(root.simpleAllowedTypes.keys());
+    for (const identifier of queue) {
+        (0, index_js_3.getOrCreate)(simpleNodeSchema, identifier, (id) => {
+            const nodeSchema = schema.definitions.get(id) ?? (0, internal_1.fail)(0xca8 /* missing schema */);
+            const transformed = transformSimpleNodeSchema(nodeSchema, options);
+            const kind = transformed.kind;
+            switch (kind) {
+                case index_js_4.NodeKind.Leaf:
+                    break;
+                case index_js_4.NodeKind.Array:
+                case index_js_4.NodeKind.Map:
+                case index_js_4.NodeKind.Record:
+                    queue.push(...transformed.simpleAllowedTypes.keys());
+                    break;
+                case index_js_4.NodeKind.Object:
+                    for (const fieldSchema of transformed.fields.values()) {
+                        queue.push(...fieldSchema.simpleAllowedTypes.keys());
+                    }
+                    break;
+                default:
+                    (0, internal_1.unreachableCase)(kind);
+            }
+            return transformed;
+        });
+    }
+    // Copy simpleNodeSchema, but in the order from the original schema.definitions
+    // Currently we do not specify anything about the order of definitions, but it is nicer to have a stable order and some tests rely on it.
+    const definitions = new Map((0, index_js_3.mapIterable)((0, index_js_3.filterIterable)(schema.definitions.keys(), (id) => simpleNodeSchema.has(id)), (id) => [id, simpleNodeSchema.get(id) ?? (0, internal_1.fail)(0xca9 /* missing schema */)]));
+    (0, internal_1.assert)(definitions.size === simpleNodeSchema.size, 0xcaa /* Reachable schema missing from input TreeSchema */);
+    return { root, definitions };
+}
+exports.transformSimpleSchema = transformSimpleSchema;
 /**
  * Convert a {@link SimpleTreeSchema} for a stored schema into a {@link TreeStoredSchema}.
  * @remarks
@@ -90,8 +137,8 @@ exports.toStoredSchema = toStoredSchema;
  */
 function simpleStoredSchemaToStoredSchema(treeSchema) {
     const result = {
-        nodeSchema: (0, internal_1.transformMapValues)(treeSchema.definitions, (schema) => getStoredSchema(schema, index_js_4.ExpectStored)),
-        rootFieldSchema: convertField(treeSchema.root, index_js_4.ExpectStored),
+        nodeSchema: (0, internal_1.transformMapValues)(treeSchema.definitions, (schema) => getStoredSchema(schema)),
+        rootFieldSchema: convertField(treeSchema.root),
     };
     return result;
 }
@@ -99,9 +146,9 @@ exports.simpleStoredSchemaToStoredSchema = simpleStoredSchemaToStoredSchema;
 /**
  * Convert a {@link SimpleFieldSchema} into a {@link TreeFieldStoredSchema}.
  */
-function convertField(schema, options) {
+function convertField(schema) {
     const kind = exports.convertFieldKind.get(schema.kind)?.identifier ?? (0, internal_1.fail)(0xae3 /* Invalid field kind */);
-    const types = (0, index_js_4.convertAllowedTypes)(schema.simpleAllowedTypes, options);
+    const types = convertAllowedTypes(schema.simpleAllowedTypes);
     return { kind, types, persistedMetadata: schema.persistedMetadata };
 }
 exports.convertField = convertField;
@@ -118,7 +165,7 @@ exports.convertFieldKind = new Map([
  * @privateRemarks
  * TODO: Persist node metadata once schema FormatV2 is supported.
  */
-function getStoredSchema(schema, options) {
+function getStoredSchema(schema) {
     const kind = schema.kind;
     switch (kind) {
         case index_js_4.NodeKind.Leaf: {
@@ -126,7 +173,7 @@ function getStoredSchema(schema, options) {
         }
         case index_js_4.NodeKind.Map:
         case index_js_4.NodeKind.Record: {
-            const types = (0, index_js_4.convertAllowedTypes)(schema.simpleAllowedTypes, options);
+            const types = convertAllowedTypes(schema.simpleAllowedTypes);
             return new index_js_1.MapNodeStoredSchema({
                 kind: index_js_2.FieldKinds.optional.identifier,
                 types,
@@ -136,12 +183,12 @@ function getStoredSchema(schema, options) {
             schema.persistedMetadata);
         }
         case index_js_4.NodeKind.Array: {
-            return arrayNodeStoredSchema(schema.simpleAllowedTypes, options, schema.persistedMetadata);
+            return arrayNodeStoredSchema(schema.simpleAllowedTypes, schema.persistedMetadata);
         }
         case index_js_4.NodeKind.Object: {
             const fields = new Map();
             for (const fieldSchema of schema.fields.values()) {
-                fields.set((0, index_js_3.brand)(fieldSchema.storedKey), convertField(fieldSchema, options));
+                fields.set((0, index_js_3.brand)(fieldSchema.storedKey), convertField(fieldSchema));
             }
             return new index_js_1.ObjectNodeStoredSchema(fields, schema.persistedMetadata);
         }
@@ -151,14 +198,142 @@ function getStoredSchema(schema, options) {
     }
 }
 exports.getStoredSchema = getStoredSchema;
-function arrayNodeStoredSchema(schema, options, persistedMetadata) {
+/**
+ * TODO: Persist node metadata once schema FormatV2 is supported.
+ *
+ * This is only exported for use by tests: if other users need them more overloads could be provided, but this is currently sufficient.
+ */
+function transformSimpleNodeSchema(schema, options) {
+    const metadata = {
+        persistedMetadata: schema.persistedMetadata,
+        metadata: preservesViewData(options)
+            ? {
+                custom: schema.metadata.custom,
+                description: schema.metadata.description,
+            }
+            : {},
+    };
+    const kind = schema.kind;
+    switch (kind) {
+        case index_js_4.NodeKind.Leaf: {
+            return {
+                kind,
+                leafKind: schema.leafKind,
+                ...metadata,
+            };
+        }
+        case index_js_4.NodeKind.Array:
+        case index_js_4.NodeKind.Map:
+        case index_js_4.NodeKind.Record: {
+            return {
+                kind,
+                ...metadata,
+                simpleAllowedTypes: filterAllowedTypes(schema.simpleAllowedTypes, options),
+            };
+        }
+        case index_js_4.NodeKind.Object: {
+            return {
+                kind,
+                ...metadata,
+                fields: (0, internal_1.transformMapValues)(schema.fields, (f) => ({
+                    ...filterFieldAllowedTypes(f, options),
+                    storedKey: f.storedKey,
+                })),
+                allowUnknownOptionalFields: filterViewData(options, schema.allowUnknownOptionalFields),
+            };
+        }
+        default: {
+            (0, internal_1.unreachableCase)(kind);
+        }
+    }
+}
+exports.transformSimpleNodeSchema = transformSimpleNodeSchema;
+function arrayNodeStoredSchema(schema, persistedMetadata) {
     const field = {
         kind: index_js_2.FieldKinds.sequence.identifier,
-        types: (0, index_js_4.convertAllowedTypes)(schema, options),
+        types: convertAllowedTypes(schema),
         persistedMetadata,
     };
     const fields = new Map([[index_js_1.EmptyKey, field]]);
     return new index_js_1.ObjectNodeStoredSchema(fields, persistedMetadata);
 }
-exports.arrayNodeStoredSchema = arrayNodeStoredSchema;
+/**
+ * Converts a {@link SimpleAllowedTypes} to a stored schema.
+ * @param schema - The schema to convert.
+ * @param options - The options to use for filtering.
+ * @returns The converted stored schema.
+ */
+function filterAllowedTypes(schema, options) {
+    const filtered = new Map();
+    for (const [type, data] of schema) {
+        if (options === index_js_4.Unchanged) {
+            filtered.set(type, { isStaged: data.isStaged });
+        }
+        else if (allowedTypeFilter(data, options)) {
+            filtered.set(type, { isStaged: undefined });
+        }
+    }
+    return filtered;
+}
+exports.filterAllowedTypes = filterAllowedTypes;
+function filterFieldAllowedTypes(f, options) {
+    return {
+        kind: f.kind,
+        persistedMetadata: f.persistedMetadata,
+        metadata: preservesViewData(options)
+            ? {
+                custom: f.metadata.custom,
+                description: f.metadata.description,
+            }
+            : {},
+        simpleAllowedTypes: filterAllowedTypes(f.simpleAllowedTypes, options),
+    };
+}
+/**
+ * Converts a stored {@link SimpleAllowedTypes} to a {@link TreeTypeSet}.
+ */
+function convertAllowedTypes(schema) {
+    return new Set(schema.keys());
+}
+/**
+ * Filters an allowed type based on the provided options.
+ * @param allowedType - The allowed type to filter.
+ * @param options - The options to use for filtering.
+ * @returns Whether the allowed type passes the filter.
+ */
+function allowedTypeFilter(data, options) {
+    if (options === index_js_4.ExpectStored) {
+        if (data.isStaged !== undefined) {
+            throw new internal_2.UsageError("Failed to covert view schema to stored schema. The simple schema provided was indicated to be a stored schema by the use of `ExpectStored`, but view schema specific content was encountered which requires a `StoredFromViewSchemaGenerationOptions` to process.");
+        }
+        return true;
+    }
+    if (data.isStaged === undefined) {
+        throw new internal_2.UsageError("Failed to covert view schema to stored schema. The simple schema provided as the view schema was actually a stored schema. If this was intended, use `ExpectStored` for the `StoredSchemaGenerationOptions` to indicate the input is already a stored schema and only a format conversion is required.");
+    }
+    // If the allowed type is staged, only include it if the options allow it.
+    if (data.isStaged === false) {
+        return true;
+    }
+    return options.includeStaged(data.isStaged);
+}
+function isStoredFromView(options) {
+    return typeof options === "object" && "includeStaged" in options;
+}
+function filterViewData(options, data) {
+    return preservesViewData(options) ? data : undefined;
+}
+/**
+ * Determines if the provided options indicate that view specific data should be preserved.
+ * @remarks
+ * This assumes that stored simple schema should not contain view specific data.
+ * Therefore the only case where what this returns should matter is when the input schema is view schema
+ * (and thus there might be view specific data).
+ */
+function preservesViewData(options) {
+    // As noted above in the doc comment, the only case we care about the return value is when the input is a view schema.
+    // There are two such cases: isStoredFromView where we return false, and Unchanged when applied to a view schema, where we return true.
+    // It does not matter what we return in other cases, so for simplicity they just end up as "true".
+    return isStoredFromView(options) ? false : true;
+}
 //# sourceMappingURL=toStoredSchema.js.map