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

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

@@ -3,8 +3,9 @@
  * Licensed under the MIT License.
  */
 import { type FieldKey, type MapTree } from "../core/index.js";
-import { type CursorWithNode, type FlexTreeNodeSchema, FlexTreeSchema, type AllowedTypeSet, FlexFieldSchema, typeNameSymbol } from "../feature-libraries/index.js";
+import { type CursorWithNode, typeNameSymbol } from "../feature-libraries/index.js";
 import { InsertableContent } from "./proxies.js";
+import { FieldSchema, type ImplicitAllowedTypes, type TreeNodeSchema } from "./schemaTypes.js";
 /**
  * Module notes:
  *
@@ -18,19 +19,17 @@ import { InsertableContent } from "./proxies.js";
 /**
  * Transforms an input {@link TypedNode} tree to a {@link MapTree}, and wraps the tree in a {@link CursorWithNode}.
  * @param data - The input tree to be converted.
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
- * @param typeSet - The set of types allowed by the parent context. Used to validate the input tree.
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
  *
  * @returns A cursor (in nodes mode) for the mapped tree if the input data was defined. Otherwise, returns `undefined`.
  */
-export declare function cursorFromNodeData(data: InsertableContent, globalSchema: FlexTreeSchema, typeSet: AllowedTypeSet): CursorWithNode<MapTree> | undefined;
-type InsertableTreeField = InsertableContent | undefined | InsertableContent[];
+export declare function cursorFromNodeData(data: InsertableContent, allowedTypes: ImplicitAllowedTypes): CursorWithNode<MapTree> | undefined;
 /**
- * Transforms an input {@link TreeField} tree to an array of {@link MapTree}s, and wraps the tree in a {@link CursorWithNode}.
+ * Transforms an input {@link InsertableContent} tree to an array of {@link MapTree}s, and wraps the tree in a {@link CursorWithNode}.
  * @param data - The input tree to be converted.
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
+ * @param schema - Schema of the field with which the input `data` is associated.
  */
-export declare function cursorFromFieldData(data: InsertableTreeField, globalSchema: FlexTreeSchema, fieldSchema: FlexFieldSchema): CursorWithNode<MapTree>;
+export declare function cursorFromFieldData(data: InsertableContent, schema: FieldSchema): CursorWithNode<MapTree>;
 /**
  * Transforms an input {@link TypedNode} tree to a {@link MapTree}.
  * @param data - The input tree to be converted.
@@ -45,22 +44,14 @@ export declare function cursorFromFieldData(data: InsertableTreeField, globalSch
  *
  * * `-0` =\> `+0`
  *
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
- * @param typeSet - The set of types allowed by the parent context. Used to validate the input tree.
+ * @param data - The tree data being transformed.
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
  */
-export declare function nodeDataToMapTree(data: InsertableContent, globalSchema: FlexTreeSchema, typeSet: AllowedTypeSet): MapTree;
-/**
- * Transforms an input {@link TreeField} tree to an array of {@link MapTree}s.
- * @param data - The input tree to be converted.
- * If the input is a sequence containing 1 or more `undefined` values, those values will be mapped as `null` if supported.
- * Othewise, an error will be thrown.
- * @param globalSchema - Schema for the whole tree. Used to select the valid types when encountering `any`.
- */
-export declare function fieldDataToMapTrees(data: InsertableTreeField, globalSchema: FlexTreeSchema, fieldSchema: FlexFieldSchema): MapTree[];
+export declare function nodeDataToMapTree(data: InsertableContent, allowedTypes: ReadonlySet<TreeNodeSchema>): MapTree;
 /**
  * @returns all types for which the data is schema-compatible.
  */
-export declare function getPossibleTypes(globalSchema: FlexTreeSchema, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): FlexTreeNodeSchema[];
+export declare function getPossibleTypes(allowedTypes: ReadonlySet<TreeNodeSchema>, data: ContextuallyTypedNodeData): TreeNodeSchema[];
 /**
  * Content of a tree which needs external schema information to interpret.
  *
@@ -89,7 +80,7 @@ export interface ContextuallyTypedNodeDataObject {
     /**
      * Fields of this node, indexed by their field keys.
      *
-     * Allow explicit undefined for compatibility with EditableTree, and type-safety on read.
+     * Allow explicit undefined for compatibility with FlexTree, and type-safety on read.
      */
     [key: FieldKey]: ContextuallyTypedFieldData;
     /**
@@ -99,5 +90,4 @@ export interface ContextuallyTypedNodeDataObject {
      */
     [key: string]: ContextuallyTypedFieldData;
 }
-export {};
 //# sourceMappingURL=toMapTree.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toMapTree.d.ts","sourceRoot":"","sources":["../../src/simple-tree/toMapTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAAY,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAIzE,OAAO,EAIN,KAAK,cAAc,EAGnB,KAAK,kBAAkB,EACvB,cAAc,EACd,KAAK,cAAc,EACnB,eAAe,EAOf,cAAc,EACd,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,cAAc,EAC5B,OAAO,EAAE,cAAc,GACrB,cAAc,CAAC,OAAO,CAAC,GAAG,SAAS,CAMrC;AAED,KAAK,mBAAmB,GAAG,iBAAiB,GAAG,SAAS,GAAG,iBAAiB,EAAE,CAAC;AAE/E;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,mBAAmB,EACzB,YAAY,EAAE,cAAc,EAC5B,WAAW,EAAE,eAAe,GAC1B,cAAc,CAAC,OAAO,CAAC,CAGzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,cAAc,EAC5B,OAAO,EAAE,cAAc,GACrB,OAAO,CA4BT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,mBAAmB,EACzB,YAAY,EAAE,cAAc,EAC5B,WAAW,EAAE,eAAe,GAC1B,OAAO,EAAE,CAkCX;AAgLD;;GAEG;AACH,wBAAgB,gBAAgB,CAC/B,YAAY,EAAE,cAAc,EAC5B,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,yBAAyB,wBAY/B;AA4CD;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAClC,+BAA+B,GAC/B,MAAM,GACN,MAAM,GACN,OAAO,GAEP,IAAI,GACJ,SAAS,yBAAyB,EAAE,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,GAAG,yBAAyB,GAAG,SAAS,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC/C;;;OAGG;IACH,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,CAAC;IAEnC;;;;OAIG;IAEH,CAAC,GAAG,EAAE,QAAQ,GAAG,0BAA0B,CAAC;IAE5C;;;;OAIG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,0BAA0B,CAAC;CAC1C"}
+{"version":3,"file":"toMapTree.d.ts","sourceRoot":"","sources":["../../src/simple-tree/toMapTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,OAAO,EAGZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACN,KAAK,cAAc,EAInB,cAAc,EAEd,MAAM,+BAA+B,CAAC;AAIvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAEN,WAAW,EACX,KAAK,oBAAoB,EAGzB,KAAK,cAAc,EAInB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,oBAAoB,GAChC,cAAc,CAAC,OAAO,CAAC,GAAG,SAAS,CAMrC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,WAAW,GACjB,cAAc,CAAC,OAAO,CAAC,CAKzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,GACvC,OAAO,CAiBT;AAuPD;;GAEG;AACH,wBAAgB,gBAAgB,CAC/B,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,EACzC,IAAI,EAAE,yBAAyB,oBAS/B;AA2ED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAClC,+BAA+B,GAC/B,MAAM,GACN,MAAM,GACN,OAAO,GAEP,IAAI,GACJ,SAAS,yBAAyB,EAAE,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,GAAG,yBAAyB,GAAG,SAAS,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC/C;;;OAGG;IACH,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,CAAC;IAEnC;;;;OAIG;IAEH,CAAC,GAAG,EAAE,QAAQ,GAAG,0BAA0B,CAAC;IAE5C;;;;OAIG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,0BAA0B,CAAC;CAC1C"}

package/dist/simple-tree/toMapTree.js

@@ -4,15 +4,14 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPossibleTypes = exports.fieldDataToMapTrees = exports.nodeDataToMapTree = exports.cursorFromFieldData = exports.cursorFromNodeData = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+exports.getPossibleTypes = exports.nodeDataToMapTree = exports.cursorFromFieldData = exports.cursorFromNodeData = 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");
-// Drilling into `domains` to reduce the magnitude of cycles introduced here
-// eslint-disable-next-line import/no-internal-modules
-const leafDomain_js_1 = require("../domains/leafDomain.js");
 const index_js_2 = require("../feature-libraries/index.js");
 const index_js_3 = require("../util/index.js");
+const leafNodeSchema_js_1 = require("./leafNodeSchema.js");
+const schemaTypes_js_1 = require("./schemaTypes.js");
 /**
  * Module notes:
  *
@@ -26,26 +25,27 @@ const index_js_3 = require("../util/index.js");
 /**
  * Transforms an input {@link TypedNode} tree to a {@link MapTree}, and wraps the tree in a {@link CursorWithNode}.
  * @param data - The input tree to be converted.
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
- * @param typeSet - The set of types allowed by the parent context. Used to validate the input tree.
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
  *
  * @returns A cursor (in nodes mode) for the mapped tree if the input data was defined. Otherwise, returns `undefined`.
  */
-function cursorFromNodeData(data, globalSchema, typeSet) {
+function cursorFromNodeData(data, allowedTypes) {
     if (data === undefined) {
         return undefined;
     }
-    const mappedContent = nodeDataToMapTree(data, globalSchema, typeSet);
+    const mappedContent = nodeDataToMapTree(data, (0, schemaTypes_js_1.normalizeAllowedTypes)(allowedTypes));
     return (0, index_js_2.cursorForMapTreeNode)(mappedContent);
 }
 exports.cursorFromNodeData = cursorFromNodeData;
 /**
- * Transforms an input {@link TreeField} tree to an array of {@link MapTree}s, and wraps the tree in a {@link CursorWithNode}.
+ * Transforms an input {@link InsertableContent} tree to an array of {@link MapTree}s, and wraps the tree in a {@link CursorWithNode}.
  * @param data - The input tree to be converted.
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
+ * @param schema - Schema of the field with which the input `data` is associated.
  */
-function cursorFromFieldData(data, globalSchema, fieldSchema) {
-    const mappedContent = fieldDataToMapTrees(data, globalSchema, fieldSchema);
+function cursorFromFieldData(data, schema) {
+    const mappedContent = Array.isArray(data)
+        ? arrayToMapTreeFields(data, schema.allowedTypeSet)
+        : [nodeDataToMapTree(data, schema.allowedTypeSet)];
     return (0, index_js_2.cursorForMapTreeField)(mappedContent);
 }
 exports.cursorFromFieldData = cursorFromFieldData;
@@ -63,82 +63,47 @@ exports.cursorFromFieldData = cursorFromFieldData;
  *
  * * `-0` =\> `+0`
  *
- * @param globalSchema - Schema for the whole tree for interperting `Any`.
- * @param typeSet - The set of types allowed by the parent context. Used to validate the input tree.
+ * @param data - The tree data being transformed.
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
  */
-function nodeDataToMapTree(data, globalSchema, typeSet) {
-    (0, core_utils_1.assert)(data !== undefined, 0x846 /* Cannot map undefined tree. */);
-    if (data === null) {
-        return valueToMapTree(data, globalSchema, typeSet);
-    }
-    switch (typeof data) {
-        case "number":
-        case "string":
-        case "boolean":
-            return valueToMapTree(data, globalSchema, typeSet);
-        default: {
-            if ((0, index_js_2.isFluidHandle)(data)) {
-                return valueToMapTree(data, globalSchema, typeSet);
-            }
-            else if (Array.isArray(data)) {
-                return arrayToMapTree(data, globalSchema, typeSet);
-            }
-            else if (data instanceof Map) {
-                return mapToMapTree(data, globalSchema, typeSet);
-            }
-            else {
-                // Assume record-like object
-                return recordToMapTree(data, globalSchema, typeSet);
-            }
-        }
+function nodeDataToMapTree(data, allowedTypes) {
+    (0, internal_1.assert)(data !== undefined, 0x846 /* Cannot map undefined tree. */);
+    const schema = getType(data, allowedTypes);
+    switch (schema.kind) {
+        case schemaTypes_js_1.NodeKind.Leaf:
+            return leafToMapTree(data, schema, allowedTypes);
+        case schemaTypes_js_1.NodeKind.Array:
+            return arrayToMapTree(data, schema);
+        case schemaTypes_js_1.NodeKind.Map:
+            return mapToMapTree(data, schema);
+        case schemaTypes_js_1.NodeKind.Object:
+            return objectToMapTree(data, schema);
+        default:
+            (0, index_js_3.fail)(`Unrecognized schema kind: ${schema.kind}.`);
     }
 }
 exports.nodeDataToMapTree = nodeDataToMapTree;
 /**
- * Transforms an input {@link TreeField} tree to an array of {@link MapTree}s.
- * @param data - The input tree to be converted.
- * If the input is a sequence containing 1 or more `undefined` values, those values will be mapped as `null` if supported.
- * Othewise, an error will be thrown.
- * @param globalSchema - Schema for the whole tree. Used to select the valid types when encountering `any`.
+ * Transforms data under a Leaf schema.
+ * @param data - The tree data to be transformed. Must be a {@link TreeValue}.
+ * @param schema - The schema associated with the value.
+ * @param allowedTypes - The allowed types specified by the parent.
+ * Used to determine which fallback values may be appropriate.
  */
-function fieldDataToMapTrees(data, globalSchema, fieldSchema) {
-    const multiplicity = fieldSchema.kind.multiplicity;
-    if (data === undefined) {
-        (0, core_utils_1.assert)(multiplicity === index_js_2.Multiplicity.Forbidden || multiplicity === index_js_2.Multiplicity.Optional, 0x847 /* `undefined` provided for a field that does not support `undefined` */);
-        return [];
+function leafToMapTree(data, schema, allowedTypes) {
+    (0, internal_1.assert)(schema.kind === schemaTypes_js_1.NodeKind.Leaf, 0x921 /* Expected a leaf schema. */);
+    if (!(0, index_js_2.isTreeValue)(data)) {
+        // This rule exists to protect against useless `toString` output like `[object Object]`.
+        // In this case, that's actually reasonable behavior, since object input is not compatible with Leaf schemas.
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        throw new internal_2.UsageError(`Input data is incompatible with leaf schema: ${data}`);
     }
-    const typeSet = fieldSchema.allowedTypeSet;
-    if (multiplicity === index_js_2.Multiplicity.Sequence) {
-        (0, core_utils_1.assert)(Array.isArray(data), 0x848 /* Expected an array as sequence input. */);
-        const children = Array.from(data, (child) => {
-            // We do not support undefined sequence entries.
-            // If we encounter an undefined entry, use null instead if supported by the schema, otherwise throw.
-            let childWithFallback = child;
-            if (child === undefined) {
-                if (typeSet === index_js_2.Any || typeSet.has(leafDomain_js_1.leaf.null)) {
-                    childWithFallback = null;
-                }
-                else {
-                    throw new TypeError(`Received unsupported array entry value: ${child}.`);
-                }
-            }
-            return nodeDataToMapTree(childWithFallback, globalSchema, typeSet);
-        });
-        return children;
-    }
-    (0, core_utils_1.assert)(multiplicity === index_js_2.Multiplicity.Single || multiplicity === index_js_2.Multiplicity.Optional, 0x849 /* A single value was provided for an unsupported field */);
-    return [nodeDataToMapTree(data, globalSchema, typeSet)];
-}
-exports.fieldDataToMapTrees = fieldDataToMapTrees;
-function valueToMapTree(
-// eslint-disable-next-line @rushstack/no-new-null
-value, globalSchema, typeSet) {
-    const mappedValue = mapValueWithFallbacks(value, typeSet);
-    const schema = getType(mappedValue, globalSchema, typeSet);
-    (0, core_utils_1.assert)(schema instanceof index_js_2.LeafNodeSchema && (0, index_js_2.allowsValue)(schema.leafValue, mappedValue), 0x84a /* Unsupported schema for provided primitive. */);
+    const mappedValue = mapValueWithFallbacks(data, allowedTypes);
+    const mappedSchema = getType(mappedValue, allowedTypes);
+    (0, internal_1.assert)(allowsValue(mappedSchema, mappedValue), 0x84a /* Unsupported schema for provided primitive. */);
     return {
         value: mappedValue,
-        type: schema.name,
+        type: (0, index_js_3.brand)(mappedSchema.identifier),
         fields: new Map(),
     };
 }
@@ -148,9 +113,7 @@ value, globalSchema, typeSet) {
  * For unsupported values without a schema-compatible replacement, throw.
  * For supported values, return the input.
  */
-function mapValueWithFallbacks(
-// eslint-disable-next-line @rushstack/no-new-null
-value, typeSet) {
+function mapValueWithFallbacks(value, allowedTypes) {
     switch (typeof value) {
         case "number": {
             if (Object.is(value, -0)) {
@@ -162,7 +125,7 @@ value, typeSet) {
                 // Our serialized data format does not support NaN nor +/-∞.
                 // If the schema supports `null`, fall back to that. Otherwise, throw.
                 // This is intended to match JSON's behavior for such values.
-                if (typeSet === index_js_2.Any || typeSet.has(leafDomain_js_1.leaf.null)) {
+                if (allowedTypes.has(leafNodeSchema_js_1.nullSchema)) {
                     return null;
                 }
                 else {
@@ -177,60 +140,127 @@ value, typeSet) {
             return value;
     }
 }
-function arrayToMapTree(data, globalSchema, typeSet) {
-    const schema = getType(data, globalSchema, typeSet);
-    (0, core_utils_1.assert)(schema instanceof index_js_2.FlexFieldNodeSchema, 0x84b /* Array data reported comparable with the schema without a primary field. */);
-    const mappedChildren = fieldDataToMapTrees(data, globalSchema, schema.info);
-    const fieldsEntries = mappedChildren.length === 0 ? [] : [[index_js_1.EmptyKey, mappedChildren]];
+function arrayToMapTreeFields(data, allowedTypes) {
+    const mappedData = [];
+    for (const child of data) {
+        // We do not support undefined sequence entries.
+        // If we encounter an undefined entry, use null instead if supported by the schema, otherwise throw.
+        let childWithFallback = child;
+        if (child === undefined) {
+            if (allowedTypes.has(leafNodeSchema_js_1.nullSchema)) {
+                childWithFallback = null;
+            }
+            else {
+                throw new TypeError(`Received unsupported array entry value: ${child}.`);
+            }
+        }
+        const mappedChild = nodeDataToMapTree(childWithFallback, allowedTypes);
+        mappedData.push(mappedChild);
+    }
+    return mappedData;
+}
+/**
+ * Transforms data under an Array schema.
+ * @param data - The tree data to be transformed. Must be an array.
+ * @param schema - The schema associated with the value.
+ * @param allowedTypes - The allowed types specified by the parent.
+ * Used to determine which fallback values may be appropriate.
+ */
+function arrayToMapTree(data, schema) {
+    (0, internal_1.assert)(schema.kind === schemaTypes_js_1.NodeKind.Array, 0x922 /* Expected an array schema. */);
+    if (!(0, index_js_3.isReadonlyArray)(data)) {
+        throw new internal_2.UsageError(`Input data is incompatible with Array schema: ${data}`);
+    }
+    const allowedChildTypes = (0, schemaTypes_js_1.normalizeAllowedTypes)(schema.info);
+    const mappedData = arrayToMapTreeFields(data, allowedChildTypes);
     // Array node children are represented as a single field entry denoted with `EmptyKey`
+    const fieldsEntries = mappedData.length === 0 ? [] : [[index_js_1.EmptyKey, mappedData]];
     const fields = new Map(fieldsEntries);
     return {
-        type: schema.name,
+        type: (0, index_js_3.brand)(schema.identifier),
         fields,
     };
 }
-function mapToMapTree(data, globalSchema, typeSet) {
-    const schema = getType(data, globalSchema, typeSet);
-    const fields = new Map();
+/**
+ * Transforms data under a Map schema.
+ * @param data - The tree data to be transformed. Must be a TypeScript Map.
+ * @param schema - The schema associated with the value.
+ * @param allowedTypes - The allowed types specified by the parent.
+ * Used to determine which fallback values may be appropriate.
+ */
+function mapToMapTree(data, schema) {
+    (0, internal_1.assert)(schema.kind === schemaTypes_js_1.NodeKind.Map, 0x923 /* Expected a Map schema. */);
+    if (!(data instanceof Map)) {
+        throw new internal_2.UsageError(`Input data is incompatible with Map schema: ${data}`);
+    }
+    const allowedChildTypes = (0, schemaTypes_js_1.normalizeAllowedTypes)(schema.info);
+    const transformedFields = new Map();
     for (const [key, value] of data) {
-        (0, core_utils_1.assert)(!fields.has((0, index_js_3.brand)(key)), 0x84c /* Keys should not be duplicated */);
-        // Omit undefined record entries - an entry with an undefined key is equivalent to no entry
+        (0, internal_1.assert)(!transformedFields.has((0, index_js_3.brand)(key)), 0x84c /* Keys should not be duplicated */);
+        // Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
         if (value !== undefined) {
-            const childSchema = schema.getFieldSchema((0, index_js_3.brand)(key));
-            const mappedField = fieldDataToMapTrees(value, globalSchema, childSchema);
-            fields.set((0, index_js_3.brand)(key), mappedField);
+            const mappedField = nodeDataToMapTree(value, allowedChildTypes);
+            transformedFields.set((0, index_js_3.brand)(key), [mappedField]);
         }
     }
     return {
-        type: schema.name,
-        fields,
+        type: (0, index_js_3.brand)(schema.identifier),
+        fields: transformedFields,
     };
 }
-function recordToMapTree(data, globalSchema, typeSet) {
-    const schema = getType(data, globalSchema, typeSet);
+/**
+ * Transforms data under an Object schema.
+ * @param data - The tree data to be transformed. Must be a Record-like object.
+ * @param schema - The schema associated with the value.
+ * @param allowedTypes - The allowed types specified by the parent.
+ * Used to determine which fallback values may be appropriate.
+ */
+function objectToMapTree(data, schema) {
+    (0, internal_1.assert)(schema.kind === schemaTypes_js_1.NodeKind.Object, 0x924 /* Expected an Object schema. */);
+    if (typeof data !== "object" || data === null) {
+        throw new internal_2.UsageError(`Input data is incompatible with Object schema: ${data}`);
+    }
     const fields = new Map();
     // Filter keys to only those that are strings - our trees do not support symbol or numeric property keys
     const keys = Reflect.ownKeys(data).filter((key) => typeof key === "string");
-    for (const key of keys) {
-        (0, core_utils_1.assert)(!fields.has(key), 0x84d /* Keys should not be duplicated */);
-        const value = data[key];
+    for (const viewKey of keys) {
+        const fieldValue = data[viewKey];
         // Omit undefined record entries - an entry with an undefined key is equivalent to no entry
-        if (value !== undefined) {
-            const childSchema = schema.getFieldSchema(key);
-            const mappedChildTree = fieldDataToMapTrees(value, globalSchema, childSchema);
-            fields.set((0, index_js_3.brand)(key), mappedChildTree);
+        if (fieldValue !== undefined) {
+            const fieldSchema = getObjectFieldSchema(schema, viewKey);
+            const mappedChildTree = nodeDataToMapTree(fieldValue, fieldSchema.allowedTypeSet);
+            const flexKey = (0, index_js_3.brand)((0, schemaTypes_js_1.getStoredKey)(viewKey, fieldSchema));
+            // Note: SchemaFactory validates this at schema creation time, with a user-friendly error.
+            // So we don't expect to hit this, and if we do it is likely an internal bug.
+            (0, internal_1.assert)(!fields.has(flexKey), 0x925 /* Keys must not be duplicated */);
+            fields.set(flexKey, [mappedChildTree]);
         }
     }
     return {
-        type: schema.name,
+        type: (0, index_js_3.brand)(schema.identifier),
         fields,
     };
 }
-function getType(data, globalSchema, typeSet) {
-    const possibleTypes = getPossibleTypes(globalSchema, typeSet, data);
-    (0, core_utils_1.assert)(possibleTypes.length !== 0, 0x84e /* data is incompatible with all types allowed by the schema */);
+function getObjectFieldSchema(schema, key) {
+    (0, internal_1.assert)(schema.kind === schemaTypes_js_1.NodeKind.Object, 0x926 /* Expected an Object schema. */);
+    const fields = schema.info;
+    if (fields[key] === undefined) {
+        (0, index_js_3.fail)(`Field "${key}" not found in schema "${schema.identifier}".`);
+    }
+    else {
+        return (0, schemaTypes_js_1.normalizeFieldSchema)(fields[key]);
+    }
+}
+function getType(data, allowedTypes) {
+    const possibleTypes = getPossibleTypes(allowedTypes, data);
+    if (possibleTypes.length === 0) {
+        throw new internal_2.UsageError(`The provided data is incompatible with all of the types allowed by the schema. The set of allowed types is: ${JSON.stringify([...allowedTypes].map((schema) => schema.identifier))}.`);
+    }
+    (0, internal_1.assert)(possibleTypes.length !== 0, 0x84e /* data is incompatible with all types allowed by the schema */);
     checkInput(possibleTypes.length === 1, () => `The provided data is compatible with more than one type allowed by the schema.
-The set of possible types is ${JSON.stringify([...possibleTypes.map((n) => n.name)], undefined)}.
+The set of possible types is ${JSON.stringify([
+        ...possibleTypes.map((schema) => schema.identifier),
+    ])}.
 Explicitly construct an unhydrated node of the desired type to disambiguate.
 For class-based schema, this can be done by replacing an expression like "{foo: 1}" with "new MySchema({foo: 1})".`);
     return possibleTypes[0];
@@ -240,7 +270,7 @@ For class-based schema, this can be done by replacing an expression like "{foo:
  * Throw and an error that properly preserves the message (unlike asserts which will get hard to read short codes intended for package internal logic errors).
  */
 function invalidInput(message) {
-    throw new telemetry_utils_1.UsageError(message);
+    throw new internal_2.UsageError(message);
 }
 function checkInput(condition, message) {
     if (!condition) {
@@ -250,13 +280,11 @@ function checkInput(condition, message) {
 /**
  * @returns all types for which the data is schema-compatible.
  */
-function getPossibleTypes(globalSchema, typeSet, data) {
-    // All types allowed by schema
-    const allowedTypes = (0, index_js_2.getAllowedTypes)(globalSchema, typeSet);
+function getPossibleTypes(allowedTypes, data) {
     const possibleTypes = [];
-    for (const allowed of allowedTypes) {
-        if (shallowCompatibilityTest(allowed, data)) {
-            possibleTypes.push(allowed);
+    for (const schema of allowedTypes) {
+        if (shallowCompatibilityTest(schema, data)) {
+            possibleTypes.push(schema);
         }
     }
     return possibleTypes;
@@ -270,30 +298,51 @@ exports.getPossibleTypes = getPossibleTypes;
  * Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.
  */
 function shallowCompatibilityTest(schema, data) {
-    (0, core_utils_1.assert)(data !== undefined, 0x889 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */);
+    (0, internal_1.assert)(data !== undefined, 0x889 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */);
     if ((0, index_js_2.isTreeValue)(data)) {
-        return schema instanceof index_js_2.LeafNodeSchema && (0, index_js_2.allowsValue)(schema.leafValue, data);
+        return allowsValue(schema, data);
     }
-    if (schema instanceof index_js_2.LeafNodeSchema) {
+    if (schema.kind === schemaTypes_js_1.NodeKind.Leaf) {
         return false;
     }
     if (index_js_2.typeNameSymbol in data) {
-        return data[index_js_2.typeNameSymbol] === schema.name;
+        return data[index_js_2.typeNameSymbol] === schema.identifier;
     }
     if ((0, index_js_3.isReadonlyArray)(data)) {
-        if (schema instanceof index_js_2.FlexFieldNodeSchema) {
-            const field = schema.getFieldSchema();
-            return field.kind.multiplicity === index_js_2.Multiplicity.Sequence;
-        }
-        else {
-            return false;
-        }
+        return schema.kind === schemaTypes_js_1.NodeKind.Array;
+    }
+    if (schema.kind === schemaTypes_js_1.NodeKind.Array) {
+        return false;
     }
     if (data instanceof Map) {
-        return schema instanceof index_js_2.FlexMapNodeSchema;
+        return schema.kind === schemaTypes_js_1.NodeKind.Map;
+    }
+    if (schema.kind === schemaTypes_js_1.NodeKind.Map) {
+        return false;
+    }
+    // Assume record-like object
+    if (schema.kind !== schemaTypes_js_1.NodeKind.Object) {
+        return false;
+    }
+    const fields = schema.info;
+    // TODO: Improve type inference by making this logic more thorough. Handle at least:
+    // * Types which are strict subsets of other types in the same polymorphic union
+    // * Types which have the same keys but different types for those keys in the polymorphic union
+    // * Types which have the same required fields but different optional fields and enough of those optional fields are populated to disambiguate
+    // TODO#7441: Consider allowing data to be inserted which has keys that are extraneous/unknown to the schema (those keys are ignored)
+    // If the schema has a required key which is not present in the input object, reject it.
+    for (const [fieldKey, fieldSchema] of Object.entries(fields)) {
+        const normalizedFieldSchema = (0, schemaTypes_js_1.normalizeFieldSchema)(fieldSchema);
+        if (data[fieldKey] === undefined && normalizedFieldSchema.kind === schemaTypes_js_1.FieldKind.Required) {
+            return false;
+        }
     }
-    // For now, consider all not explicitly typed objects shallow compatible.
-    // This will require explicit differentiation in polymorphic cases rather than automatic structural differentiation.
     return true;
 }
+function allowsValue(schema, value) {
+    if (schema.kind === schemaTypes_js_1.NodeKind.Leaf) {
+        return (0, index_js_2.valueSchemaAllows)(schema.info, value);
+    }
+    return false;
+}
 //# sourceMappingURL=toMapTree.js.map