@fluidframework/tree 2.1.0 → 2.2.0

package/lib/simple-tree/toMapTree.js

@@ -2,53 +2,59 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 import { EmptyKey, } from "../core/index.js";
-import { cursorForMapTreeField, cursorForMapTreeNode, isTreeValue, typeNameSymbol, valueSchemaAllows, isMapTreeNode, } from "../feature-libraries/index.js";
+import { isTreeValue, valueSchemaAllows, isMapTreeNode, } from "../feature-libraries/index.js";
 import { brand, fail, isReadonlyArray, find } from "../util/index.js";
 import { nullSchema } from "./leafNodeSchema.js";
-import { FieldKind, FieldSchema, NodeKind, normalizeAllowedTypes, normalizeFieldSchema, getStoredKey, extractFieldProvider, isConstant, } from "./schemaTypes.js";
+import { normalizeAllowedTypes, extractFieldProvider, isConstant, normalizeFieldSchema, FieldKind, } from "./schemaTypes.js";
+import { NodeKind, tryGetSimpleNodeSchema } from "./core/index.js";
 import { isNodeInSchema } from "../feature-libraries/index.js";
-import { tryGetFlexNode } from "./proxyBinding.js";
-export function cursorFromNodeData(data, allowedTypes, context, schemaValidationPolicy) {
-    if (data === undefined) {
-        return undefined;
-    }
-    const mappedContent = nodeDataToMapTree(data, normalizeAllowedTypes(allowedTypes), schemaValidationPolicy);
-    addDefaultsToMapTree(mappedContent, allowedTypes, context);
-    return cursorForMapTreeNode(mappedContent);
-}
-export function cursorFromFieldData(data, schema, context, schemaValidationPolicy) {
-    if (data === undefined) {
-        return undefined;
-    }
-    // TODO: array node content should not go through here since sequence fields don't exist at this abstraction layer.
-    const mappedContent = Array.isArray(data)
-        ? arrayToMapTreeFields(data, schema.allowedTypeSet, schemaValidationPolicy)
-        : [nodeDataToMapTree(data, schema.allowedTypeSet, schemaValidationPolicy)];
-    for (const content of mappedContent) {
-        addDefaultsToMapTree(content, schema.allowedTypes, context);
-    }
-    return cursorForMapTreeField(mappedContent);
-}
+import { tryGetInnerNode } from "./proxyBinding.js";
+import { isObjectNodeSchema } from "./objectNodeTypes.js";
 export function mapTreeFromNodeData(data, allowedTypes, context, schemaValidationPolicy) {
+    const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
     if (data === undefined) {
+        // TODO: this code-path should support defaults
+        if (normalizedFieldSchema.kind !== FieldKind.Optional) {
+            throw new UsageError("Got undefined for non-optional field.");
+        }
         return undefined;
     }
-    const mapTree = nodeDataToMapTree(data, normalizeAllowedTypes(allowedTypes), schemaValidationPolicy);
-    addDefaultsToMapTree(mapTree, allowedTypes, context);
+    const mapTree = nodeDataToMapTree(data, normalizedFieldSchema.allowedTypeSet);
+    // Add what defaults can be provided. If no `context` is providing, some defaults may still be missing.
+    addDefaultsToMapTree(mapTree, normalizedFieldSchema.allowedTypes, context);
+    // TODO:
+    // Since some defaults may still be missing, this can give false positives when context is undefined but schemaValidationPolicy is provided.
+    if (schemaValidationPolicy?.policy.validateSchema === true) {
+        const maybeError = isNodeInSchema(mapTree, schemaValidationPolicy);
+        inSchemaOrThrow(maybeError);
+    }
     return mapTree;
 }
-function nodeDataToMapTree(data, allowedTypes, schemaValidationPolicy) {
-    if (data === undefined) {
-        return undefined;
-    }
+/**
+ * Copy content from `data` into a MapTree.
+ * Does NOT generate and default values for fields.
+ * Often throws UsageErrors for invalid data, but may miss some cases.
+ * @remarks
+ * Output is likely out of schema even for valid input due to missing defaults.
+ */
+function nodeDataToMapTree(data, allowedTypes) {
     // A special cache path for processing unhydrated nodes.
     // They already have the mapTree, so there is no need to recompute it.
-    const flexNode = tryGetFlexNode(data);
+    const flexNode = tryGetInnerNode(data);
     if (flexNode !== undefined) {
         if (isMapTreeNode(flexNode)) {
+            if (!allowedTypes.has(tryGetSimpleNodeSchema(flexNode.schema) ?? fail("missing schema"))) {
+                throw new UsageError("Invalid schema for this context.");
+            }
+            // TODO: mapTreeFromNodeData modifies the trees it gets to add defaults.
+            // Using a cached value here can result in this tree having defaults applied to it more than once.
+            // This is unnecessary and inefficient, but should be a no-op if all calls provide the same context (which they might not).
+            // A cleaner design (avoiding this cast) might be to apply defaults eagerly if they don't need a context, and lazily (when hydrating) if they do.
+            // This could avoid having to mutate the map tree to apply defaults, removing the need for this cast.
             return flexNode.mapTree;
         }
         else {
@@ -74,14 +80,16 @@ function nodeDataToMapTree(data, allowedTypes, schemaValidationPolicy) {
         default:
             fail(`Unrecognized schema kind: ${schema.kind}.`);
     }
-    if (schemaValidationPolicy?.policy.validateSchema === true) {
-        const maybeError = isNodeInSchema(result, schemaValidationPolicy);
-        if (maybeError !== 0 /* SchemaValidationErrors.NoError */) {
-            throw new UsageError("Tree does not conform to schema.");
-        }
-    }
     return result;
 }
+/**
+ * Throws a UsageError if maybeError indicates a tree is out of schema.
+ */
+export function inSchemaOrThrow(maybeError) {
+    if (maybeError !== 0 /* SchemaValidationErrors.NoError */) {
+        throw new UsageError("Tree does not conform to schema.");
+    }
+}
 /**
  * Transforms data under a Leaf schema.
  * @param data - The tree data to be transformed. Must be a {@link TreeValue}.
@@ -107,7 +115,7 @@ function leafToMapTree(data, schema, allowedTypes) {
     };
 }
 /**
- * Checks an incoming value to ensure it is compatible with our serialization format.
+ * Checks an incoming {@link TreeLeafValue} to ensure it is compatible with its requirements.
  * For unsupported values with a schema-compatible replacement, return the replacement value.
  * For unsupported values without a schema-compatible replacement, throw.
  * For supported values, return the input.
@@ -135,40 +143,43 @@ function mapValueWithFallbacks(value, allowedTypes) {
                 return value;
             }
         }
-        default:
+        case "string":
+        // TODO:
+        // This should detect invalid strings. Something like @stdlib/regexp-utf16-unpaired-surrogate could be used to do this.
+        // See SchemaFactory.string for details.
+        case "boolean":
             return value;
+        case "object": {
+            if (value === null || isFluidHandle(value)) {
+                return value;
+            }
+        }
+        default:
+            throw new TypeError(`Received unsupported leaf value: ${value}.`);
     }
 }
 /**
  * Transforms data under an Array schema.
  * @param data - The tree data to be transformed.
  * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
- * @param schemaValidationPolicy - The stored schema and policy to be used for validation, if the policy says schema
- * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
- * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
  */
-function arrayToMapTreeFields(data, allowedTypes, schemaValidationPolicy) {
-    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(nullSchema)) {
-                childWithFallback = null;
-            }
-            else {
-                throw new TypeError(`Received unsupported array entry value: ${child}.`);
-            }
+function arrayChildToMapTree(child, allowedTypes) {
+    // 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(nullSchema)) {
+            childWithFallback = null;
+        }
+        else {
+            throw new TypeError(`Received unsupported array entry value: ${child}.`);
         }
-        const mappedChild = nodeDataToMapTree(childWithFallback, allowedTypes, schemaValidationPolicy);
-        mappedData.push(mappedChild);
     }
-    return mappedData;
+    return nodeDataToMapTree(childWithFallback, allowedTypes);
 }
 /**
  * Transforms data under an Array schema.
- * @param data - The tree data to be transformed. Must be an array.
+ * @param data - The tree data to be transformed. Must be an iterable.
  * @param schema - The schema associated with the value.
  * @param schemaValidationPolicy - The stored schema and policy to be used for validation, if the policy says schema
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
@@ -176,22 +187,21 @@ function arrayToMapTreeFields(data, allowedTypes, schemaValidationPolicy) {
  */
 function arrayToMapTree(data, schema) {
     assert(schema.kind === NodeKind.Array, 0x922 /* Expected an array schema. */);
-    if (!isReadonlyArray(data)) {
+    if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
         throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
     }
     const allowedChildTypes = normalizeAllowedTypes(schema.info);
-    const mappedData = arrayToMapTreeFields(data, allowedChildTypes, undefined);
-    // Array node children are represented as a single field entry denoted with `EmptyKey`
+    const mappedData = Array.from(data, (child) => arrayChildToMapTree(child, allowedChildTypes));
+    // Array nodes have a single `EmptyKey` field:
     const fieldsEntries = mappedData.length === 0 ? [] : [[EmptyKey, mappedData]];
-    const fields = new Map(fieldsEntries);
     return {
         type: brand(schema.identifier),
-        fields,
+        fields: new Map(fieldsEntries),
     };
 }
 /**
  * Transforms data under a Map schema.
- * @param data - The tree data to be transformed. Must be a TypeScript Map.
+ * @param data - The tree data to be transformed. Must be an iterable.
  * @param schema - The schema associated with the value.
  * @param schemaValidationPolicy - The stored schema and policy to be used for validation, if the policy says schema
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
@@ -199,16 +209,25 @@ function arrayToMapTree(data, schema) {
  */
 function mapToMapTree(data, schema) {
     assert(schema.kind === NodeKind.Map, 0x923 /* Expected a Map schema. */);
-    if (!(data instanceof Map)) {
+    if (!(typeof data === "object" && data !== null)) {
         throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
     }
     const allowedChildTypes = normalizeAllowedTypes(schema.info);
+    const fieldsIterator = (Symbol.iterator in data
+        ? // Support iterables of key value pairs (including Map objects)
+            data
+        : // Support record objects for JSON style Map data
+            Object.entries(data));
     const transformedFields = new Map();
-    for (const [key, value] of data) {
+    for (const item of fieldsIterator) {
+        if (!isReadonlyArray(item) || item.length !== 2 || typeof item[0] !== "string") {
+            throw new UsageError(`Input data is incompatible with map entry: ${item}`);
+        }
+        const [key, value] = item;
         assert(!transformedFields.has(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 mappedField = nodeDataToMapTree(value, allowedChildTypes, undefined);
+            const mappedField = nodeDataToMapTree(value, allowedChildTypes);
             transformedFields.set(brand(key), [mappedField]);
         }
     }
@@ -223,16 +242,17 @@ function mapToMapTree(data, schema) {
  * @param schema - The schema associated with the value.
  */
 function objectToMapTree(data, schema) {
-    assert(schema.kind === NodeKind.Object, 0x924 /* Expected an Object schema. */);
+    assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
     if (typeof data !== "object" || data === null) {
         throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
     }
     const fields = new Map();
-    // Loop through field keys without data, and assign value from its default provider.
-    for (const key of Object.keys(schema.info)) {
-        const value = data[key];
-        if (value !== undefined && Object.hasOwnProperty.call(data, key)) {
-            setFieldValue(fields, value, getObjectFieldSchema(schema, key), key);
+    // Loop through field keys without data.
+    // This does NOT apply defaults.
+    for (const [key, fieldInfo] of schema.flexKeyMap) {
+        if (Object.hasOwnProperty.call(data, key)) {
+            const value = data[key];
+            setFieldValue(fields, value, fieldInfo.schema, fieldInfo.storedKey);
         }
     }
     return {
@@ -240,62 +260,69 @@ function objectToMapTree(data, schema) {
         fields,
     };
 }
-function setFieldValue(fields, fieldValue, fieldSchema, key) {
+function setFieldValue(fields, fieldValue, fieldSchema, flexKey) {
     if (fieldValue !== undefined) {
-        const mappedChildTree = nodeDataToMapTree(fieldValue, fieldSchema.allowedTypeSet, undefined);
-        const flexKey = brand(getStoredKey(key, fieldSchema));
+        const mappedChildTree = nodeDataToMapTree(fieldValue, fieldSchema.allowedTypeSet);
         assert(!fields.has(flexKey), 0x956 /* Keys must not be duplicated */);
         fields.set(flexKey, [mappedChildTree]);
     }
 }
-function getObjectFieldSchema(schema, key) {
-    assert(schema.kind === NodeKind.Object, 0x926 /* Expected an Object schema. */);
-    const fields = schema.info;
-    if (fields[key] === undefined) {
-        fail(`Field "${key}" not found in schema "${schema.identifier}".`);
-    }
-    else {
-        return normalizeFieldSchema(fields[key]);
-    }
-}
 function getType(data, allowedTypes) {
     const possibleTypes = getPossibleTypes(allowedTypes, data);
     if (possibleTypes.length === 0) {
         throw new 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))}.`);
     }
     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.
+    if (possibleTypes.length !== 1) {
+        throw new UsageError(`The provided data is compatible with more than one type allowed by the schema.
 The set of possible types is ${JSON.stringify([
-        ...possibleTypes.map((schema) => schema.identifier),
-    ])}.
+            ...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];
-}
-/**
- * An invalid tree has been provided, presumably by the user of this package.
- * 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 UsageError(message);
-}
-function checkInput(condition, message) {
-    if (!condition) {
-        invalidInput(typeof message === "string" ? message : message());
     }
+    return possibleTypes[0] ?? oob();
 }
 /**
  * @returns all types for which the data is schema-compatible.
  */
 export function getPossibleTypes(allowedTypes, data) {
+    let best = CompatibilityLevel.None;
     const possibleTypes = [];
     for (const schema of allowedTypes) {
-        if (shallowCompatibilityTest(schema, data)) {
+        const level = shallowCompatibilityTest(schema, data);
+        if (level > best) {
+            possibleTypes.length = 0;
+            best = level;
+        }
+        if (best === level) {
             possibleTypes.push(schema);
         }
     }
-    return possibleTypes;
+    return best === CompatibilityLevel.None ? [] : possibleTypes;
 }
+/**
+ * Indicates a compatibility level for inferring a schema to apply to insertable data.
+ * @remarks
+ * Only the highest compatibility options are used.
+ * This approach allows adding new possible matching at a new lower compatibility level as a non breaking change,
+ * since that way they can't make a case that was compatible before ambiguous now.
+ */
+var CompatibilityLevel;
+(function (CompatibilityLevel) {
+    /**
+     * Not compatible. Constructor typing indicates incompatibility.
+     */
+    CompatibilityLevel[CompatibilityLevel["None"] = 0] = "None";
+    /**
+     * Additional compatibility cases added in Fluid Framework 2.2.
+     */
+    CompatibilityLevel[CompatibilityLevel["Low"] = 1] = "Low";
+    /**
+     * Compatible in Fluid Framework 2.0.
+     */
+    CompatibilityLevel[CompatibilityLevel["Normal"] = 2] = "Normal";
+})(CompatibilityLevel || (CompatibilityLevel = {}));
 /**
  * Checks if data might be schema-compatible.
  *
@@ -306,44 +333,65 @@ export function getPossibleTypes(allowedTypes, data) {
 function shallowCompatibilityTest(schema, data) {
     assert(data !== undefined, 0x889 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */);
     if (isTreeValue(data)) {
-        return allowsValue(schema, data);
+        return allowsValue(schema, data) ? CompatibilityLevel.Normal : CompatibilityLevel.None;
     }
     if (schema.kind === NodeKind.Leaf) {
-        return false;
-    }
-    if (typeNameSymbol in data) {
-        return data[typeNameSymbol] === schema.identifier;
+        return CompatibilityLevel.None;
+    }
+    // Typing (of schema based constructors and thus implicit node construction)
+    // allows iterables for constructing maps and arrays.
+    // Some users of this API may have unions of maps and arrays,
+    // and rely on Arrays ending up as array nodes and maps as Map nodes,
+    // despite both being iterable and thus compatible with both.
+    // This uses a priority based system where an array would be parsed as an array when unioned with a map,
+    // but if in a map only context, could still be used as a map.
+    if (data instanceof Map) {
+        switch (schema.kind) {
+            case NodeKind.Map:
+                return CompatibilityLevel.Normal;
+            case NodeKind.Array:
+                // Maps are iterable, so type checking does allow constructing an ArrayNode from a map if the array's type is an array that includes the key and value types of the map.
+                return CompatibilityLevel.Low;
+            default:
+                return CompatibilityLevel.None;
+        }
     }
     if (isReadonlyArray(data)) {
-        return schema.kind === NodeKind.Array;
+        switch (schema.kind) {
+            case NodeKind.Array:
+                return CompatibilityLevel.Normal;
+            case NodeKind.Map:
+                // Arrays are iterable, so type checking does allow constructing an array from a MapNode from an if the array's type is key values pairs for the map.
+                return CompatibilityLevel.Low;
+            default:
+                return CompatibilityLevel.None;
+        }
     }
-    if (schema.kind === NodeKind.Array) {
-        return false;
+    const mapOrArray = schema.kind === NodeKind.Array || schema.kind === NodeKind.Map;
+    if (Symbol.iterator in data) {
+        return mapOrArray ? CompatibilityLevel.Normal : CompatibilityLevel.None;
     }
-    if (data instanceof Map) {
-        return schema.kind === NodeKind.Map;
+    // At this point, it is assumed data is a record-like object since all the other cases have been eliminated.
+    if (schema.kind === NodeKind.Array) {
+        return CompatibilityLevel.None;
     }
     if (schema.kind === NodeKind.Map) {
-        return false;
-    }
-    // Assume record-like object
-    if (schema.kind !== NodeKind.Object) {
-        return false;
+        // When not unioned with an ObjectNode, allow objects to be used to create maps.
+        return CompatibilityLevel.Low;
     }
-    const fields = schema.info;
+    assert(isObjectNodeSchema(schema), 0x9e6 /* unexpected schema kind */);
     // 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 = normalizeFieldSchema(fieldSchema);
-        if (data[fieldKey] === undefined && normalizedFieldSchema.kind === FieldKind.Required) {
-            return false;
+    for (const [fieldKey, fieldSchema] of schema.fields) {
+        if (data[fieldKey] === undefined && fieldSchema.requiresValue) {
+            return CompatibilityLevel.None;
         }
     }
-    return true;
+    return CompatibilityLevel.Normal;
 }
 function allowsValue(schema, value) {
     if (schema.kind === NodeKind.Leaf) {
@@ -352,18 +400,43 @@ function allowsValue(schema, value) {
     return false;
 }
 /**
- * Walk the given {@link MapTree} and provide any field defaults for fields that are missing in the tree but present in the schema.
- * @param mapTree - The tree to populate with defaults
+ * Walk the given {@link ExclusiveMapTree} and deeply provide any field defaults for fields that are missing in the tree but present in the schema.
+ * @param mapTree - The tree to populate with defaults. This is borrowed: no references to it are kept by this function.
  * @param allowedTypes - Some {@link TreeNodeSchema}, at least one of which the input tree must conform to
  * @param context - An optional context for generating defaults.
  * If present, all applicable defaults will be provided.
  * If absent, only defaults produced by a {@link ConstantFieldProvider} will be provided, and defaults produced by a {@link ContextualFieldProvider} will be ignored.
- * @remarks This function mutates the input tree by adding new fields to the field maps where applicable.
- * @privateRemarks TODO: Create a more established type for mutable MapTrees, and use where appropriate.
+ * @remarks This function mutates the input tree by deeply adding new fields to the field maps where applicable.
  */
-function addDefaultsToMapTree(mapTree, allowedTypes, context) {
+export function addDefaultsToMapTree(mapTree, allowedTypes, context) {
     const schema = find(normalizeAllowedTypes(allowedTypes), (s) => s.identifier === mapTree.type) ??
         fail("MapTree is incompatible with schema");
+    if (isObjectNodeSchema(schema)) {
+        for (const [_key, fieldInfo] of schema.flexKeyMap) {
+            const field = mapTree.fields.get(fieldInfo.storedKey);
+            if (field !== undefined) {
+                for (const child of field) {
+                    addDefaultsToMapTree(child, fieldInfo.schema.allowedTypes, context);
+                }
+            }
+            else {
+                const defaultProvider = fieldInfo.schema.props?.defaultProvider;
+                if (defaultProvider !== undefined) {
+                    const fieldProvider = extractFieldProvider(defaultProvider);
+                    const data = provideDefault(fieldProvider, context);
+                    if (data !== undefined) {
+                        setFieldValue(mapTree.fields, data, fieldInfo.schema, fieldInfo.storedKey);
+                        // call addDefaultsToMapTree on newly inserted default values
+                        for (const child of mapTree.fields.get(fieldInfo.storedKey) ??
+                            fail("Expected field to be populated")) {
+                            addDefaultsToMapTree(child, fieldInfo.schema.allowedTypes, context);
+                        }
+                    }
+                }
+            }
+        }
+        return;
+    }
     switch (schema.kind) {
         case NodeKind.Array:
         case NodeKind.Map:
@@ -375,38 +448,17 @@ function addDefaultsToMapTree(mapTree, allowedTypes, context) {
                 }
             }
             break;
-        case NodeKind.Object:
-            {
-                for (const [key, fieldSchema] of Object.entries(schema.info)) {
-                    const field = mapTree.fields.get(key);
-                    if (field !== undefined) {
-                        for (const child of field) {
-                            addDefaultsToMapTree(child, getObjectFieldSchema(schema, key).allowedTypes, context);
-                        }
-                    }
-                    else if (fieldSchema instanceof FieldSchema) {
-                        const defaultProvider = fieldSchema.props?.defaultProvider;
-                        if (defaultProvider !== undefined) {
-                            const fieldProvider = extractFieldProvider(defaultProvider);
-                            const data = provideDefault(fieldProvider, context);
-                            if (data !== undefined) {
-                                const mutableMapTree = mapTree;
-                                setFieldValue(mutableMapTree.fields, data, fieldSchema, key);
-                                for (const child of mutableMapTree.fields.get(key) ??
-                                    fail("Expected field to be populated")) {
-                                    addDefaultsToMapTree(child, fieldSchema.allowedTypes, context);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            break;
         default:
             assert(schema.kind === NodeKind.Leaf, 0x989 /* Unrecognized schema kind */);
             break;
     }
 }
+/**
+ * Provides the default value (which can be undefined, for example with optional fields), or undefined if a context is required but not provided.
+ * @privateRemarks
+ * It is a bit concerning that there is no way for the caller to know when undefined is returned if that is the default value, or a context was required.
+ * TODO: maybe better formalize the two stage defaulting (without then with context), or rework this design we only do one stage.
+ */
 function provideDefault(fieldProvider, context) {
     if (context !== undefined) {
         return fieldProvider(context);
@@ -415,6 +467,10 @@ function provideDefault(fieldProvider, context) {
         if (isConstant(fieldProvider)) {
             return fieldProvider();
         }
+        else {
+            // Leaving field empty despite it needing a default value since a context was required and non was provided.
+            // Caller better handle this case by providing the default at some other point in time when the context becomes known.
+        }
     }
 }
 //# sourceMappingURL=toMapTree.js.map