@fluidframework/tree 2.41.0-338401 → 2.42.0

package/lib/simple-tree/unhydratedFlexTreeFromInsertable.d.ts

@@ -0,0 +1,72 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type ImplicitFieldSchema } from "./schemaTypes.js";
+import { type TreeNode, type TreeNodeSchema, type Unhydrated, UnhydratedFlexTreeNode } from "./core/index.js";
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
+/**
+ * Module notes:
+ *
+ * The flow of the below code is in terms of the structure of the input data. We then verify that the associated
+ * schema is appropriate for that kind of data. This is fine while we have a 1:1 mapping of kind of input data to
+ * the kind of schema we expect for it (e.g. an input that is an array always need to be associated with a sequence in
+ * the schema). If/when we begin accepting kinds of input data that are ambiguous (e.g. accepting an input that is an
+ * array of key/value tuples to instantiate a map) we may need to rethink the structure here to be based more on the
+ * schema than on the input data.
+ */
+/**
+ * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.
+ * @param data - The input tree to be converted.
+ * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,
+ * otherwise an error will be thrown.
+ *
+ * Fallbacks:
+ *
+ * * `NaN` =\> `null`
+ *
+ * * `+/-∞` =\> `null`
+ *
+ * * `-0` =\> `+0`
+ *
+ * For fields with a default value, the field may be omitted.
+ * If `context` is not provided, defaults which require a context will be left empty which can be out of schema.
+ *
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
+ * @remarks
+ * The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.
+ *
+ * Often throws UsageErrors for invalid data, but may miss some cases.
+ *
+ * Output should comply with the provided view schema, but this is not explicitly validated:
+ * validation against stored schema (to guard against document corruption) is done elsewhere.
+ */
+export declare function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(data: TIn, allowedTypes: ImplicitFieldSchema): TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
+/**
+ * Returns all types for which the data is schema-compatible.
+ */
+export declare function getPossibleTypes(allowedTypes: ReadonlySet<TreeNodeSchema>, data: FactoryContent): TreeNodeSchema[];
+/**
+ * Content which can be used to build a node.
+ * @remarks
+ * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
+ * @system @alpha
+ */
+export type FactoryContent = IFluidHandle | string | number | boolean | null | Iterable<readonly [string, InsertableContent]> | readonly InsertableContent[] | FactoryContentObject;
+/**
+ * Record-like object which can be used to build some kinds of nodes.
+ * @remarks
+ * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
+ *
+ * Supports object and map nodes.
+ * @system @alpha
+ */
+export type FactoryContentObject = {
+    readonly [P in string]?: InsertableContent;
+};
+/**
+ * Content which can be inserted into a tree.
+ * @system @alpha
+ */
+export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;
+//# sourceMappingURL=unhydratedFlexTreeFromInsertable.d.ts.map

package/lib/simple-tree/unhydratedFlexTreeFromInsertable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unhydratedFlexTreeFromInsertable.d.ts","sourceRoot":"","sources":["../../src/simple-tree/unhydratedFlexTreeFromInsertable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH,OAAO,EAIN,KAAK,mBAAmB,EAMxB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAIN,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,sBAAsB,EAEtB,MAAM,iBAAiB,CAAC;AAOzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAMpE;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAAC,GAAG,SAAS,iBAAiB,GAAG,SAAS,EACzF,IAAI,EAAE,GAAG,EACT,YAAY,EAAE,mBAAmB,GAC/B,GAAG,SAAS,SAAS,GAAG,SAAS,GAAG,sBAAsB,CAiB5D;AAkVD;;GAEG;AACH,wBAAgB,gBAAgB,CAC/B,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,EACzC,IAAI,EAAE,cAAc,GAClB,cAAc,EAAE,CAclB;AAyHD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACvB,YAAY,GACZ,MAAM,GACN,MAAM,GACN,OAAO,GAEP,IAAI,GACJ,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,GAC9C,SAAS,iBAAiB,EAAE,GAC5B,oBAAoB,CAAC;AAExB;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,iBAAiB;CAC1C,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,cAAc,CAAC"}

package/lib/simple-tree/{toMapTree.js → unhydratedFlexTreeFromInsertable.js}

@@ -6,13 +6,58 @@ import { assert, fail, unreachableCase } from "@fluidframework/core-utils/intern
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 import { EmptyKey, } from "../core/index.js";
-import { isTreeValue, valueSchemaAllows, } from "../feature-libraries/index.js";
-import { brand, isReadonlyArray, find, hasSome, hasSingle } from "../util/index.js";
+import { FieldKinds, isTreeValue, valueSchemaAllows } from "../feature-libraries/index.js";
+import { brand, isReadonlyArray, hasSingle } from "../util/index.js";
 import { nullSchema } from "./leafNodeSchema.js";
-import { normalizeAllowedTypes, extractFieldProvider, isConstant, normalizeFieldSchema, FieldKind, } from "./schemaTypes.js";
-import { getKernel, getSimpleNodeSchemaFromInnerNode, isTreeNode, NodeKind, UnhydratedFlexTreeNode, } from "./core/index.js";
-import { isObjectNodeSchema } from "./objectNodeTypes.js";
-export function mapTreeFromNodeData(data, allowedTypes, context) {
+import { normalizeAllowedTypes, isConstant, normalizeFieldSchema, FieldKind, extractFieldProvider, } from "./schemaTypes.js";
+import { getKernel, isTreeNode, NodeKind, UnhydratedFlexTreeNode, UnhydratedSequenceField, } from "./core/index.js";
+// Required to prevent the introduction of new circular dependencies
+// TODO: Having the schema provide their own policy functions for compatibility which
+// unhydratedFlexTreeFromInsertable invokes instead of manually handling each kind would remove this bad
+// dependency, and reduce coupling.
+// eslint-disable-next-line import/no-internal-modules
+import { isObjectNodeSchema } from "./node-kinds/object/objectNodeTypes.js";
+// eslint-disable-next-line import/no-internal-modules
+import { createField } from "./core/unhydratedFlexTree.js";
+import { convertFieldKind } from "./toStoredSchema.js";
+import { getUnhydratedContext } from "./createContext.js";
+/**
+ * Module notes:
+ *
+ * The flow of the below code is in terms of the structure of the input data. We then verify that the associated
+ * schema is appropriate for that kind of data. This is fine while we have a 1:1 mapping of kind of input data to
+ * the kind of schema we expect for it (e.g. an input that is an array always need to be associated with a sequence in
+ * the schema). If/when we begin accepting kinds of input data that are ambiguous (e.g. accepting an input that is an
+ * array of key/value tuples to instantiate a map) we may need to rethink the structure here to be based more on the
+ * schema than on the input data.
+ */
+/**
+ * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.
+ * @param data - The input tree to be converted.
+ * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,
+ * otherwise an error will be thrown.
+ *
+ * Fallbacks:
+ *
+ * * `NaN` =\> `null`
+ *
+ * * `+/-∞` =\> `null`
+ *
+ * * `-0` =\> `+0`
+ *
+ * For fields with a default value, the field may be omitted.
+ * If `context` is not provided, defaults which require a context will be left empty which can be out of schema.
+ *
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
+ * @remarks
+ * The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.
+ *
+ * Often throws UsageErrors for invalid data, but may miss some cases.
+ *
+ * Output should comply with the provided view schema, but this is not explicitly validated:
+ * validation against stored schema (to guard against document corruption) is done elsewhere.
+ */
+export function unhydratedFlexTreeFromInsertable(data, allowedTypes) {
     const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
     if (data === undefined) {
         // TODO: this code-path should support defaults
@@ -21,59 +66,46 @@ export function mapTreeFromNodeData(data, allowedTypes, context) {
         }
         return undefined;
     }
-    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);
-    return mapTree;
+    const flexTree = unhydratedFlexTreeFromInsertableNode(data, normalizedFieldSchema.allowedTypeSet);
+    return flexTree;
 }
 /**
- * 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.
+ * Copy content from `data` into a UnhydratedFlexTreeNode.
  */
-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 innerNode = tryGetInnerNode(data);
-    if (innerNode !== undefined) {
-        if (innerNode instanceof UnhydratedFlexTreeNode) {
-            if (!allowedTypes.has(getSimpleNodeSchemaFromInnerNode(innerNode))) {
-                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 innerNode.mapTree;
-        }
-        else {
+function unhydratedFlexTreeFromInsertableNode(data, allowedTypes) {
+    if (isTreeNode(data)) {
+        const kernel = getKernel(data);
+        const inner = kernel.getInnerNodeIfUnhydrated();
+        if (inner === undefined) {
             // The node is already hydrated, meaning that it already got inserted into the tree previously
             throw new UsageError("A node may not be inserted into the tree more than once");
         }
+        else {
+            if (!allowedTypes.has(kernel.schema)) {
+                throw new UsageError("Invalid schema for this context.");
+            }
+            return inner;
+        }
     }
-    assert(!isTreeNode(data), 0xa23 /* data without an inner node cannot be TreeNode */);
     const schema = getType(data, allowedTypes);
     let result;
     switch (schema.kind) {
         case NodeKind.Leaf:
-            result = leafToMapTree(data, schema, allowedTypes);
+            result = leafToFlexContent(data, schema, allowedTypes);
             break;
         case NodeKind.Array:
-            result = arrayToMapTree(data, schema);
+            result = arrayToFlexContent(data, schema);
             break;
         case NodeKind.Map:
-            result = mapToMapTree(data, schema);
+            result = mapToFlexContent(data, schema);
             break;
         case NodeKind.Object:
-            result = objectToMapTree(data, schema);
+            result = objectToFlexContent(data, schema);
             break;
         default:
             unreachableCase(schema.kind);
     }
-    return result;
+    return new UnhydratedFlexTreeNode(...result, getUnhydratedContext(schema));
 }
 /**
  * Transforms data under a Leaf schema.
@@ -82,7 +114,7 @@ function nodeDataToMapTree(data, allowedTypes) {
  * @param allowedTypes - The allowed types specified by the parent.
  * Used to determine which fallback values may be appropriate.
  */
-function leafToMapTree(data, schema, allowedTypes) {
+function leafToFlexContent(data, schema, allowedTypes) {
     assert(schema.kind === NodeKind.Leaf, 0x921 /* Expected a leaf schema. */);
     if (!isTreeValue(data)) {
         // This rule exists to protect against useless `toString` output like `[object Object]`.
@@ -93,11 +125,13 @@ function leafToMapTree(data, schema, allowedTypes) {
     const mappedValue = mapValueWithFallbacks(data, allowedTypes);
     const mappedSchema = getType(mappedValue, allowedTypes);
     assert(allowsValue(mappedSchema, mappedValue), 0x84a /* Unsupported schema for provided primitive. */);
-    return {
-        value: mappedValue,
-        type: brand(mappedSchema.identifier),
-        fields: new Map(),
-    };
+    return [
+        {
+            value: mappedValue,
+            type: brand(mappedSchema.identifier),
+        },
+        new Map(),
+    ];
 }
 /**
  * Checks an incoming {@link TreeLeafValue} to ensure it is compatible with its requirements.
@@ -148,7 +182,7 @@ function mapValueWithFallbacks(value, allowedTypes) {
  * @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.
  */
-function arrayChildToMapTree(child, allowedTypes) {
+function arrayChildToFlexTree(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;
@@ -160,39 +194,43 @@ function arrayChildToMapTree(child, allowedTypes) {
             throw new TypeError(`Received unsupported array entry value: ${child}.`);
         }
     }
-    return nodeDataToMapTree(childWithFallback, allowedTypes);
+    return unhydratedFlexTreeFromInsertableNode(childWithFallback, allowedTypes);
 }
 /**
  * Transforms data under an Array schema.
  * @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
- * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
  */
-function arrayToMapTree(data, schema) {
+function arrayToFlexContent(data, schema) {
     assert(schema.kind === NodeKind.Array, 0x922 /* Expected an array schema. */);
     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 = Array.from(data, (child) => arrayChildToMapTree(child, allowedChildTypes));
+    const mappedData = Array.from(data, (child) => arrayChildToFlexTree(child, allowedChildTypes));
+    const context = getUnhydratedContext(schema).flexContext;
     // Array nodes have a single `EmptyKey` field:
-    const fieldsEntries = mappedData.length === 0 ? [] : [[EmptyKey, mappedData]];
-    return {
-        type: brand(schema.identifier),
-        fields: new Map(fieldsEntries),
-    };
+    const fieldsEntries = mappedData.length === 0
+        ? []
+        : [
+            [
+                EmptyKey,
+                new UnhydratedSequenceField(context, FieldKinds.sequence.identifier, EmptyKey, mappedData),
+            ],
+        ];
+    return [
+        {
+            type: brand(schema.identifier),
+        },
+        new Map(fieldsEntries),
+    ];
 }
 /**
  * Transforms data under a Map schema.
  * @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
- * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
  */
-function mapToMapTree(data, schema) {
+function mapToFlexContent(data, schema) {
     assert(schema.kind === NodeKind.Map, 0x923 /* Expected a Map schema. */);
     if (!(typeof data === "object" && data !== null)) {
         throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
@@ -203,6 +241,7 @@ function mapToMapTree(data, schema) {
             data
         : // Support record objects for JSON style Map data
             Object.entries(data));
+    const context = getUnhydratedContext(schema).flexContext;
     const transformedFields = new Map();
     for (const item of fieldsIterator) {
         if (!isReadonlyArray(item) || item.length !== 2 || typeof item[0] !== "string") {
@@ -212,21 +251,24 @@ function mapToMapTree(data, schema) {
         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);
-            transformedFields.set(brand(key), [mappedField]);
+            const child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);
+            const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
+            transformedFields.set(brand(key), field);
         }
     }
-    return {
-        type: brand(schema.identifier),
-        fields: transformedFields,
-    };
+    return [
+        {
+            type: brand(schema.identifier),
+        },
+        transformedFields,
+    ];
 }
 /**
  * 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.
  */
-function objectToMapTree(data, schema) {
+function objectToFlexContent(data, schema) {
     assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
     if (typeof data !== "object" ||
         data === null ||
@@ -235,44 +277,52 @@ function objectToMapTree(data, schema) {
         throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
     }
     const fields = new Map();
-    // Loop through field keys without data.
-    // This does NOT apply defaults.
+    const context = getUnhydratedContext(schema).flexContext;
     for (const [key, fieldInfo] of schema.flexKeyMap) {
-        if (checkFieldProperty(data, key)) {
-            const value = data[key];
-            setFieldValue(fields, value, fieldInfo.schema, fieldInfo.storedKey);
+        const value = getFieldProperty(data, key);
+        let children;
+        if (value === undefined) {
+            const defaultProvider = fieldInfo.schema.props?.defaultProvider ??
+                fail(0xbb1 /* missing field has no default provider */);
+            const fieldProvider = extractFieldProvider(defaultProvider);
+            children = isConstant(fieldProvider) ? fieldProvider() : fieldProvider;
         }
+        else {
+            children = [
+                unhydratedFlexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet),
+            ];
+        }
+        const kind = convertFieldKind.get(fieldInfo.schema.kind) ?? fail(0xbb2 /* Invalid field kind */);
+        fields.set(fieldInfo.storedKey, createField(context, kind.identifier, fieldInfo.storedKey, children));
     }
-    return {
-        type: brand(schema.identifier),
-        fields,
-    };
+    return [{ type: brand(schema.identifier) }, fields];
 }
 /**
  * Check {@link FactoryContentObject} for a property which could be store a field.
+ *
+ * @returns If the property exists, return its value. Otherwise, returns undefined.
  * @remarks
  * The currently policy is to only consider own properties.
  * See {@link InsertableObjectFromSchemaRecord} for where this policy is documented in the public API.
  *
- * Explicit undefined members are considered to exist, as long as they are own properties.
+ * Explicit undefined values are treated the same as missing properties to allow explicit use of undefined with defaulted identifiers.
+ *
+ * @privateRemarks
+ * If we ever want to have an optional field which defaults to something other than undefined, this will need changes.
+ * It would need to adjusting the handling of explicit undefined in contexts where undefined is allowed, and a default provider also exists.
  */
-function checkFieldProperty(data, key) {
+function getFieldProperty(data, key) {
     // This policy only allows own properties.
-    return Object.hasOwnProperty.call(data, key);
-}
-function setFieldValue(fields, fieldValue, fieldSchema, flexKey) {
-    if (fieldValue !== undefined) {
-        const mappedChildTree = nodeDataToMapTree(fieldValue, fieldSchema.allowedTypeSet);
-        assert(!fields.has(flexKey), 0x956 /* Keys must not be duplicated */);
-        fields.set(flexKey, [mappedChildTree]);
+    if (Object.hasOwnProperty.call(data, key)) {
+        return data[key];
     }
+    return undefined;
 }
 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(hasSome(possibleTypes), 0x84e /* data is incompatible with all types allowed by the schema */);
     if (!hasSingle(possibleTypes)) {
         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([
@@ -388,12 +438,7 @@ function shallowCompatibilityTest(schema, data) {
     // If the schema has a required key which is not present in the input object, reject it.
     for (const [fieldKey, fieldSchema] of schema.fields) {
         if (fieldSchema.requiresValue) {
-            if (checkFieldProperty(data, fieldKey)) {
-                if (data[fieldKey] === undefined) {
-                    return CompatibilityLevel.None;
-                }
-            }
-            else {
+            if (getFieldProperty(data, fieldKey) === undefined) {
                 return CompatibilityLevel.None;
             }
         }
@@ -406,90 +451,4 @@ function allowsValue(schema, value) {
     }
     return false;
 }
-/**
- * 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 deeply adding new fields to the field maps where applicable.
- */
-export function addDefaultsToMapTree(mapTree, allowedTypes, context) {
-    const schema = find(normalizeAllowedTypes(allowedTypes), (s) => s.identifier === mapTree.type) ??
-        fail(0xae1 /* 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(0xae2 /* Expected field to be populated */)) {
-                            addDefaultsToMapTree(child, fieldInfo.schema.allowedTypes, context);
-                        }
-                    }
-                }
-            }
-        }
-        return;
-    }
-    switch (schema.kind) {
-        case NodeKind.Array:
-        case NodeKind.Map:
-            {
-                for (const field of mapTree.fields.values()) {
-                    for (const child of field) {
-                        addDefaultsToMapTree(child, schema.info, 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);
-    }
-    else {
-        if (isConstant(fieldProvider)) {
-            return fieldProvider();
-        }
-        else {
-            // Leaving field empty despite it needing a default value since a context was required and none was provided.
-            // Caller better handle this case by providing the default at some other point in time when the context becomes known.
-        }
-    }
-}
-/**
- * Retrieves the InnerNode associated with the given target via {@link setInnerNode}, if any.
- * @remarks
- * If `target` is a unhydrated node, returns its MapTreeNode.
- * If `target` is a cooked node (or marinated but a FlexTreeNode exists) returns the FlexTreeNode.
- * If the target is not a node, or a marinated node with no FlexTreeNode for its anchor, returns undefined.
- */
-function tryGetInnerNode(target) {
-    if (isTreeNode(target)) {
-        return getKernel(target).tryGetInnerNode();
-    }
-}
-//# sourceMappingURL=toMapTree.js.map
+//# sourceMappingURL=unhydratedFlexTreeFromInsertable.js.map

package/lib/simple-tree/unhydratedFlexTreeFromInsertable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unhydratedFlexTreeFromInsertable.js","sourceRoot":"","sources":["../../src/simple-tree/unhydratedFlexTreeFromInsertable.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, fail, unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\n\nimport {\n\tEmptyKey,\n\ttype FieldKey,\n\ttype NodeData,\n\ttype TreeValue,\n\ttype ValueSchema,\n} from \"../core/index.js\";\nimport { FieldKinds, isTreeValue, valueSchemaAllows } from \"../feature-libraries/index.js\";\nimport { brand, isReadonlyArray, hasSingle } from \"../util/index.js\";\n\nimport { nullSchema } from \"./leafNodeSchema.js\";\nimport {\n\ttype ImplicitAllowedTypes,\n\tnormalizeAllowedTypes,\n\tisConstant,\n\ttype ImplicitFieldSchema,\n\tnormalizeFieldSchema,\n\tFieldKind,\n\ttype TreeLeafValue,\n\textractFieldProvider,\n\ttype ContextualFieldProvider,\n} from \"./schemaTypes.js\";\nimport {\n\tgetKernel,\n\tisTreeNode,\n\tNodeKind,\n\ttype TreeNode,\n\ttype TreeNodeSchema,\n\ttype Unhydrated,\n\tUnhydratedFlexTreeNode,\n\tUnhydratedSequenceField,\n} from \"./core/index.js\";\n// Required to prevent the introduction of new circular dependencies\n// TODO: Having the schema provide their own policy functions for compatibility which\n// unhydratedFlexTreeFromInsertable invokes instead of manually handling each kind would remove this bad\n// dependency, and reduce coupling.\n// eslint-disable-next-line import/no-internal-modules\nimport { isObjectNodeSchema } from \"./node-kinds/object/objectNodeTypes.js\";\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\n// eslint-disable-next-line import/no-internal-modules\nimport { createField, type UnhydratedFlexTreeField } from \"./core/unhydratedFlexTree.js\";\nimport { convertFieldKind } from \"./toStoredSchema.js\";\nimport { getUnhydratedContext } from \"./createContext.js\";\n\n/**\n * Module notes:\n *\n * The flow of the below code is in terms of the structure of the input data. We then verify that the associated\n * schema is appropriate for that kind of data. This is fine while we have a 1:1 mapping of kind of input data to\n * the kind of schema we expect for it (e.g. an input that is an array always need to be associated with a sequence in\n * the schema). If/when we begin accepting kinds of input data that are ambiguous (e.g. accepting an input that is an\n * array of key/value tuples to instantiate a map) we may need to rethink the structure here to be based more on the\n * schema than on the input data.\n */\n\n/**\n * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.\n * @param data - The input tree to be converted.\n * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,\n * otherwise an error will be thrown.\n *\n * Fallbacks:\n *\n * * `NaN` =\\> `null`\n *\n * * `+/-∞` =\\> `null`\n *\n * * `-0` =\\> `+0`\n *\n * For fields with a default value, the field may be omitted.\n * If `context` is not provided, defaults which require a context will be left empty which can be out of schema.\n *\n * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.\n * @remarks\n * The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.\n *\n * Often throws UsageErrors for invalid data, but may miss some cases.\n *\n * Output should comply with the provided view schema, but this is not explicitly validated:\n * validation against stored schema (to guard against document corruption) is done elsewhere.\n */\nexport function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(\n\tdata: TIn,\n\tallowedTypes: ImplicitFieldSchema,\n): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {\n\tconst normalizedFieldSchema = normalizeFieldSchema(allowedTypes);\n\n\tif (data === undefined) {\n\t\t// TODO: this code-path should support defaults\n\t\tif (normalizedFieldSchema.kind !== FieldKind.Optional) {\n\t\t\tthrow new UsageError(\"Got undefined for non-optional field.\");\n\t\t}\n\t\treturn undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n\t}\n\n\tconst flexTree: UnhydratedFlexTreeNode = unhydratedFlexTreeFromInsertableNode(\n\t\tdata,\n\t\tnormalizedFieldSchema.allowedTypeSet,\n\t);\n\n\treturn flexTree as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n}\n\n/**\n * Copy content from `data` into a UnhydratedFlexTreeNode.\n */\nfunction unhydratedFlexTreeFromInsertableNode(\n\tdata: InsertableContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): UnhydratedFlexTreeNode {\n\tif (isTreeNode(data)) {\n\t\tconst kernel = getKernel(data);\n\t\tconst inner = kernel.getInnerNodeIfUnhydrated();\n\t\tif (inner === undefined) {\n\t\t\t// The node is already hydrated, meaning that it already got inserted into the tree previously\n\t\t\tthrow new UsageError(\"A node may not be inserted into the tree more than once\");\n\t\t} else {\n\t\t\tif (!allowedTypes.has(kernel.schema)) {\n\t\t\t\tthrow new UsageError(\"Invalid schema for this context.\");\n\t\t\t}\n\t\t\treturn inner;\n\t\t}\n\t}\n\n\tconst schema = getType(data, allowedTypes);\n\n\tlet result: FlexContent;\n\tswitch (schema.kind) {\n\t\tcase NodeKind.Leaf:\n\t\t\tresult = leafToFlexContent(data, schema, allowedTypes);\n\t\t\tbreak;\n\t\tcase NodeKind.Array:\n\t\t\tresult = arrayToFlexContent(data, schema);\n\t\t\tbreak;\n\t\tcase NodeKind.Map:\n\t\t\tresult = mapToFlexContent(data, schema);\n\t\t\tbreak;\n\t\tcase NodeKind.Object:\n\t\t\tresult = objectToFlexContent(data, schema);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tunreachableCase(schema.kind);\n\t}\n\n\treturn new UnhydratedFlexTreeNode(...result, getUnhydratedContext(schema));\n}\n\ntype FlexContent = [NodeData, Map<FieldKey, UnhydratedFlexTreeField>];\n\n/**\n * Transforms data under a Leaf schema.\n * @param data - The tree data to be transformed. Must be a {@link TreeValue}.\n * @param schema - The schema associated with the value.\n * @param allowedTypes - The allowed types specified by the parent.\n * Used to determine which fallback values may be appropriate.\n */\nfunction leafToFlexContent(\n\tdata: FactoryContent,\n\tschema: TreeNodeSchema,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): FlexContent {\n\tassert(schema.kind === NodeKind.Leaf, 0x921 /* Expected a leaf schema. */);\n\tif (!isTreeValue(data)) {\n\t\t// This rule exists to protect against useless `toString` output like `[object Object]`.\n\t\t// In this case, that's actually reasonable behavior, since object input is not compatible with Leaf schemas.\n\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\tthrow new UsageError(`Input data is incompatible with leaf schema: ${data}`);\n\t}\n\n\tconst mappedValue = mapValueWithFallbacks(data, allowedTypes);\n\tconst mappedSchema = getType(mappedValue, allowedTypes);\n\n\tassert(\n\t\tallowsValue(mappedSchema, mappedValue),\n\t\t0x84a /* Unsupported schema for provided primitive. */,\n\t);\n\n\treturn [\n\t\t{\n\t\t\tvalue: mappedValue,\n\t\t\ttype: brand(mappedSchema.identifier),\n\t\t},\n\t\tnew Map<FieldKey, UnhydratedFlexTreeField>(),\n\t];\n}\n\n/**\n * Checks an incoming {@link TreeLeafValue} to ensure it is compatible with its requirements.\n * For unsupported values with a schema-compatible replacement, return the replacement value.\n * For unsupported values without a schema-compatible replacement, throw.\n * For supported values, return the input.\n */\nfunction mapValueWithFallbacks(\n\tvalue: TreeLeafValue,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): TreeValue {\n\tswitch (typeof value) {\n\t\tcase \"number\": {\n\t\t\tif (Object.is(value, -0)) {\n\t\t\t\t// Our serialized data format does not support -0.\n\t\t\t\t// Map such input to +0.\n\t\t\t\treturn 0;\n\t\t\t} else if (!Number.isFinite(value)) {\n\t\t\t\t// Our serialized data format does not support NaN nor +/-∞.\n\t\t\t\t// If the schema supports `null`, fall back to that. Otherwise, throw.\n\t\t\t\t// This is intended to match JSON's behavior for such values.\n\t\t\t\tif (allowedTypes.has(nullSchema)) {\n\t\t\t\t\treturn null;\n\t\t\t\t} else {\n\t\t\t\t\tthrow new UsageError(`Received unsupported numeric value: ${value}.`);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t\tcase \"string\":\n\t\t// TODO:\n\t\t// This should detect invalid strings. Something like @stdlib/regexp-utf16-unpaired-surrogate could be used to do this.\n\t\t// See SchemaFactory.string for details.\n\t\tcase \"boolean\":\n\t\t\treturn value;\n\t\tcase \"object\": {\n\t\t\tif (value === null || isFluidHandle(value)) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t\tdefault:\n\t\t\tthrow new UsageError(`Received unsupported leaf value: ${value}.`);\n\t}\n}\n\n/**\n * Transforms data under an Array schema.\n * @param data - The tree data to be transformed.\n * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.\n */\nfunction arrayChildToFlexTree(\n\tchild: InsertableContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): UnhydratedFlexTreeNode {\n\t// We do not support undefined sequence entries.\n\t// If we encounter an undefined entry, use null instead if supported by the schema, otherwise throw.\n\tlet childWithFallback = child;\n\tif (child === undefined) {\n\t\tif (allowedTypes.has(nullSchema)) {\n\t\t\tchildWithFallback = null;\n\t\t} else {\n\t\t\tthrow new TypeError(`Received unsupported array entry value: ${child}.`);\n\t\t}\n\t}\n\treturn unhydratedFlexTreeFromInsertableNode(childWithFallback, allowedTypes);\n}\n\n/**\n * Transforms data under an Array schema.\n * @param data - The tree data to be transformed. Must be an iterable.\n * @param schema - The schema associated with the value.\n */\nfunction arrayToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {\n\tassert(schema.kind === NodeKind.Array, 0x922 /* Expected an array schema. */);\n\tif (!(typeof data === \"object\" && data !== null && Symbol.iterator in data)) {\n\t\tthrow new UsageError(`Input data is incompatible with Array schema: ${data}`);\n\t}\n\n\tconst allowedChildTypes = normalizeAllowedTypes(schema.info as ImplicitAllowedTypes);\n\n\tconst mappedData = Array.from(data, (child) =>\n\t\tarrayChildToFlexTree(child, allowedChildTypes),\n\t);\n\n\tconst context = getUnhydratedContext(schema).flexContext;\n\n\t// Array nodes have a single `EmptyKey` field:\n\tconst fieldsEntries =\n\t\tmappedData.length === 0\n\t\t\t? []\n\t\t\t: ([\n\t\t\t\t\t[\n\t\t\t\t\t\tEmptyKey,\n\t\t\t\t\t\tnew UnhydratedSequenceField(\n\t\t\t\t\t\t\tcontext,\n\t\t\t\t\t\t\tFieldKinds.sequence.identifier,\n\t\t\t\t\t\t\tEmptyKey,\n\t\t\t\t\t\t\tmappedData,\n\t\t\t\t\t\t),\n\t\t\t\t\t],\n\t\t\t\t] as const);\n\n\treturn [\n\t\t{\n\t\t\ttype: brand(schema.identifier),\n\t\t},\n\t\tnew Map(fieldsEntries),\n\t];\n}\n\n/**\n * Transforms data under a Map schema.\n * @param data - The tree data to be transformed. Must be an iterable.\n * @param schema - The schema associated with the value.\n */\nfunction mapToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {\n\tassert(schema.kind === NodeKind.Map, 0x923 /* Expected a Map schema. */);\n\tif (!(typeof data === \"object\" && data !== null)) {\n\t\tthrow new UsageError(`Input data is incompatible with Map schema: ${data}`);\n\t}\n\n\tconst allowedChildTypes = normalizeAllowedTypes(schema.info as ImplicitAllowedTypes);\n\n\tconst fieldsIterator = (\n\t\tSymbol.iterator in data\n\t\t\t? // Support iterables of key value pairs (including Map objects)\n\t\t\t\tdata\n\t\t\t: // Support record objects for JSON style Map data\n\t\t\t\tObject.entries(data)\n\t) as Iterable<readonly [string, InsertableContent]>;\n\n\tconst context = getUnhydratedContext(schema).flexContext;\n\n\tconst transformedFields = new Map<FieldKey, UnhydratedFlexTreeField>();\n\tfor (const item of fieldsIterator) {\n\t\tif (!isReadonlyArray(item) || item.length !== 2 || typeof item[0] !== \"string\") {\n\t\t\tthrow new UsageError(`Input data is incompatible with map entry: ${item}`);\n\t\t}\n\t\tconst [key, value] = item;\n\t\tassert(!transformedFields.has(brand(key)), 0x84c /* Keys should not be duplicated */);\n\n\t\t// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted\n\t\tif (value !== undefined) {\n\t\t\tconst child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);\n\t\t\tconst field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);\n\t\t\ttransformedFields.set(brand(key), field);\n\t\t}\n\t}\n\n\treturn [\n\t\t{\n\t\t\ttype: brand(schema.identifier),\n\t\t},\n\t\ttransformedFields,\n\t];\n}\n\n/**\n * Transforms data under an Object schema.\n * @param data - The tree data to be transformed. Must be a Record-like object.\n * @param schema - The schema associated with the value.\n */\nfunction objectToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {\n\tassert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);\n\tif (\n\t\ttypeof data !== \"object\" ||\n\t\tdata === null ||\n\t\tSymbol.iterator in data ||\n\t\tisFluidHandle(data)\n\t) {\n\t\tthrow new UsageError(`Input data is incompatible with Object schema: ${data}`);\n\t}\n\n\tconst fields = new Map<FieldKey, UnhydratedFlexTreeField>();\n\tconst context = getUnhydratedContext(schema).flexContext;\n\n\tfor (const [key, fieldInfo] of schema.flexKeyMap) {\n\t\tconst value = getFieldProperty(data, key);\n\n\t\tlet children: UnhydratedFlexTreeNode[] | ContextualFieldProvider;\n\t\tif (value === undefined) {\n\t\t\tconst defaultProvider =\n\t\t\t\tfieldInfo.schema.props?.defaultProvider ??\n\t\t\t\tfail(0xbb1 /* missing field has no default provider */);\n\t\t\tconst fieldProvider = extractFieldProvider(defaultProvider);\n\t\t\tchildren = isConstant(fieldProvider) ? fieldProvider() : fieldProvider;\n\t\t} else {\n\t\t\tchildren = [\n\t\t\t\tunhydratedFlexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet),\n\t\t\t];\n\t\t}\n\n\t\tconst kind =\n\t\t\tconvertFieldKind.get(fieldInfo.schema.kind) ?? fail(0xbb2 /* Invalid field kind */);\n\t\tfields.set(\n\t\t\tfieldInfo.storedKey,\n\t\t\tcreateField(context, kind.identifier, fieldInfo.storedKey, children),\n\t\t);\n\t}\n\n\treturn [{ type: brand(schema.identifier) }, fields];\n}\n\n/**\n * Check {@link FactoryContentObject} for a property which could be store a field.\n *\n * @returns If the property exists, return its value. Otherwise, returns undefined.\n * @remarks\n * The currently policy is to only consider own properties.\n * See {@link InsertableObjectFromSchemaRecord} for where this policy is documented in the public API.\n *\n * Explicit undefined values are treated the same as missing properties to allow explicit use of undefined with defaulted identifiers.\n *\n * @privateRemarks\n * If we ever want to have an optional field which defaults to something other than undefined, this will need changes.\n * It would need to adjusting the handling of explicit undefined in contexts where undefined is allowed, and a default provider also exists.\n */\nfunction getFieldProperty(\n\tdata: FactoryContentObject,\n\tkey: string | symbol,\n): InsertableContent | undefined {\n\t// This policy only allows own properties.\n\tif (Object.hasOwnProperty.call(data, key)) {\n\t\treturn (data as Record<string, InsertableContent>)[key as string];\n\t}\n\treturn undefined;\n}\n\nfunction getType(\n\tdata: FactoryContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): TreeNodeSchema {\n\tconst possibleTypes = getPossibleTypes(allowedTypes, data);\n\tif (possibleTypes.length === 0) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is incompatible with all of the types allowed by the schema. The set of allowed types is: ${JSON.stringify(\n\t\t\t\t[...allowedTypes].map((schema) => schema.identifier),\n\t\t\t)}.`,\n\t\t);\n\t}\n\tif (!hasSingle(possibleTypes)) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is compatible with more than one type allowed by the schema.\nThe set of possible types is ${JSON.stringify([\n\t\t\t\t...possibleTypes.map((schema) => schema.identifier),\n\t\t\t])}.\nExplicitly construct an unhydrated node of the desired type to disambiguate.\nFor class-based schema, this can be done by replacing an expression like \"{foo: 1}\" with \"new MySchema({foo: 1})\".`,\n\t\t);\n\t}\n\treturn possibleTypes[0];\n}\n\n/**\n * Returns all types for which the data is schema-compatible.\n */\nexport function getPossibleTypes(\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\tdata: FactoryContent,\n): TreeNodeSchema[] {\n\tlet best = CompatibilityLevel.None;\n\tconst possibleTypes: TreeNodeSchema[] = [];\n\tfor (const schema of allowedTypes) {\n\t\tconst level = shallowCompatibilityTest(schema, data);\n\t\tif (level > best) {\n\t\t\tpossibleTypes.length = 0;\n\t\t\tbest = level;\n\t\t}\n\t\tif (best === level) {\n\t\t\tpossibleTypes.push(schema);\n\t\t}\n\t}\n\treturn best === CompatibilityLevel.None ? [] : possibleTypes;\n}\n\n/**\n * Indicates a compatibility level for inferring a schema to apply to insertable data.\n * @remarks\n * Only the highest compatibility options are used.\n * This approach allows adding new possible matching at a new lower compatibility level as a non breaking change,\n * since that way they can't make a case that was compatible before ambiguous now.\n */\nenum CompatibilityLevel {\n\t/**\n\t * Not compatible. Constructor typing indicates incompatibility.\n\t */\n\tNone = 0,\n\t/**\n\t * Additional compatibility cases added in Fluid Framework 2.2.\n\t */\n\tLow = 1,\n\t/**\n\t * Compatible in Fluid Framework 2.0.\n\t */\n\tNormal = 2,\n}\n\n/**\n * Checks if data might be schema-compatible.\n *\n * @returns false if `data` is incompatible with `type` based on a cheap/shallow check.\n *\n * 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.\n */\nfunction shallowCompatibilityTest(\n\tschema: TreeNodeSchema,\n\tdata: FactoryContent,\n): CompatibilityLevel {\n\tassert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);\n\n\tif (isTreeValue(data)) {\n\t\treturn allowsValue(schema, data) ? CompatibilityLevel.Normal : CompatibilityLevel.None;\n\t}\n\tif (schema.kind === NodeKind.Leaf) {\n\t\treturn CompatibilityLevel.None;\n\t}\n\n\t// Typing (of schema based constructors and thus implicit node construction)\n\t// allows iterables for constructing maps and arrays.\n\t// Some users of this API may have unions of maps and arrays,\n\t// and rely on Arrays ending up as array nodes and maps as Map nodes,\n\t// despite both being iterable and thus compatible with both.\n\t// This uses a priority based system where an array would be parsed as an array when unioned with a map,\n\t// but if in a map only context, could still be used as a map.\n\n\tif (data instanceof Map) {\n\t\tswitch (schema.kind) {\n\t\t\tcase NodeKind.Map:\n\t\t\t\treturn CompatibilityLevel.Normal;\n\t\t\tcase NodeKind.Array:\n\t\t\t\t// 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.\n\t\t\t\treturn CompatibilityLevel.Low;\n\t\t\tdefault:\n\t\t\t\treturn CompatibilityLevel.None;\n\t\t}\n\t}\n\n\tif (isReadonlyArray(data)) {\n\t\tswitch (schema.kind) {\n\t\t\tcase NodeKind.Array:\n\t\t\t\treturn CompatibilityLevel.Normal;\n\t\t\tcase NodeKind.Map:\n\t\t\t\t// 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.\n\t\t\t\treturn CompatibilityLevel.Low;\n\t\t\tdefault:\n\t\t\t\treturn CompatibilityLevel.None;\n\t\t}\n\t}\n\n\tconst mapOrArray = schema.kind === NodeKind.Array || schema.kind === NodeKind.Map;\n\n\tif (Symbol.iterator in data) {\n\t\treturn mapOrArray ? CompatibilityLevel.Normal : CompatibilityLevel.None;\n\t}\n\n\t// At this point, it is assumed data is a record-like object since all the other cases have been eliminated.\n\n\tif (schema.kind === NodeKind.Array) {\n\t\treturn CompatibilityLevel.None;\n\t}\n\n\tif (schema.kind === NodeKind.Map) {\n\t\t// When not unioned with an ObjectNode, allow objects to be used to create maps.\n\t\treturn CompatibilityLevel.Low;\n\t}\n\n\tassert(isObjectNodeSchema(schema), 0x9e6 /* unexpected schema kind */);\n\n\t// TODO: Improve type inference by making this logic more thorough. Handle at least:\n\t// * Types which are strict subsets of other types in the same polymorphic union\n\t// * Types which have the same keys but different types for those keys in the polymorphic union\n\t// * Types which have the same required fields but different optional fields and enough of those optional fields are populated to disambiguate\n\n\t// TODO#7441: Consider allowing data to be inserted which has keys that are extraneous/unknown to the schema (those keys are ignored)\n\n\t// If the schema has a required key which is not present in the input object, reject it.\n\tfor (const [fieldKey, fieldSchema] of schema.fields) {\n\t\tif (fieldSchema.requiresValue) {\n\t\t\tif (getFieldProperty(data, fieldKey) === undefined) {\n\t\t\t\treturn CompatibilityLevel.None;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn CompatibilityLevel.Normal;\n}\n\nfunction allowsValue(schema: TreeNodeSchema, value: TreeValue): boolean {\n\tif (schema.kind === NodeKind.Leaf) {\n\t\treturn valueSchemaAllows(schema.info as ValueSchema, value);\n\t}\n\treturn false;\n}\n\n/**\n * Content which can be used to build a node.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n * @system @alpha\n */\nexport type FactoryContent =\n\t| IFluidHandle\n\t| string\n\t| number\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| Iterable<readonly [string, InsertableContent]>\n\t| readonly InsertableContent[]\n\t| FactoryContentObject;\n\n/**\n * Record-like object which can be used to build some kinds of nodes.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n *\n * Supports object and map nodes.\n * @system @alpha\n */\nexport type FactoryContentObject = {\n\treadonly [P in string]?: InsertableContent;\n};\n\n/**\n * Content which can be inserted into a tree.\n * @system @alpha\n */\nexport type InsertableContent = Unhydrated<TreeNode> | FactoryContent;\n"]}

package/lib/simple-tree/walkFieldSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"walkFieldSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/walkFieldSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAoB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE5F,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,kBAAkB,CAAC;AAElF;;GAEG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,aAAa,EACtB,UAAU,GAAE,GAAG,CAAC,cAAc,CAAa,GACzC,IAAI,CAEN"}
+{"version":3,"file":"walkFieldSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/walkFieldSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAoB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,kBAAkB,CAAC;AAElF;;GAEG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,aAAa,EACtB,UAAU,GAAE,GAAG,CAAC,cAAc,CAAa,GACzC,IAAI,CAEN"}

package/lib/simple-tree/walkFieldSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"walkFieldSchema.js","sourceRoot":"","sources":["../../src/simple-tree/walkFieldSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuB,gBAAgB,EAAsB,MAAM,iBAAiB,CAAC;AAE5F,OAAO,EAA4B,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAElF;;GAEG;AACH,MAAM,UAAU,eAAe,CAC9B,MAA2B,EAC3B,OAAsB,EACtB,aAAkC,IAAI,GAAG,EAAE;IAE3C,gBAAgB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;AACpF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from \"./core/index.js\";\n\nimport { type ImplicitFieldSchema, normalizeFieldSchema } from \"./schemaTypes.js\";\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.\n */\nexport function walkFieldSchema(\n\tschema: ImplicitFieldSchema,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema> = new Set(),\n): void {\n\twalkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);\n}\n"]}
+{"version":3,"file":"walkFieldSchema.js","sourceRoot":"","sources":["../../src/simple-tree/walkFieldSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuB,gBAAgB,EAAsB,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAA4B,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAElF;;GAEG;AACH,MAAM,UAAU,eAAe,CAC9B,MAA2B,EAC3B,OAAsB,EACtB,aAAkC,IAAI,GAAG,EAAE;IAE3C,gBAAgB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;AACpF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from \"./core/index.js\";\nimport { type ImplicitFieldSchema, normalizeFieldSchema } from \"./schemaTypes.js\";\n\n/**\n * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.\n */\nexport function walkFieldSchema(\n\tschema: ImplicitFieldSchema,\n\tvisitor: SchemaVisitor,\n\tvisitedSet: Set<TreeNodeSchema> = new Set(),\n): void {\n\twalkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);\n}\n"]}