@fluidframework/tree 2.50.0 → 2.51.0-347100

package/dist/simple-tree/leafNodeSchema.js

@@ -3,12 +3,28 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LeafNodeSchema_initializedData, _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleSchema = exports.nullSchema = exports.booleanSchema = exports.numberSchema = exports.stringSchema = exports.LeafNodeSchema = void 0;
+exports.leafToFlexContent = exports.handleSchema = exports.nullSchema = exports.booleanSchema = exports.numberSchema = exports.stringSchema = exports.LeafNodeSchema = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/telemetry-utils/internal");
+const internal_3 = require("@fluidframework/runtime-utils/internal");
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("../feature-libraries/index.js");
 const index_js_3 = require("./core/index.js");
+const index_js_4 = require("../util/index.js");
+const createContext_js_1 = require("./createContext.js");
 /**
  * Instances of this class are schema for leaf nodes.
  * @remarks
@@ -34,7 +50,14 @@ class LeafNodeSchema {
         this.kind = index_js_3.NodeKind.Leaf;
         this.implicitlyConstructable = true;
         this.childTypes = new Set();
-        this.childAnnotatedAllowedTypes = [];
+        this[_a] = {
+            idempotentInitialize: () => (__classPrivateFieldSet(this, _LeafNodeSchema_initializedData, __classPrivateFieldGet(this, _LeafNodeSchema_initializedData, "f") ?? (0, createContext_js_1.getTreeNodeSchemaInitializedData)(this, {
+                shallowCompatibilityTest: (data) => shallowCompatibilityTest(this, data),
+                toFlexContent: (data, allowedTypes) => leafToFlexContent(data, this, allowedTypes),
+            }), "f")),
+            childAnnotatedAllowedTypes: [],
+        };
+        _LeafNodeSchema_initializedData.set(this, void 0);
         this.metadata = {};
         this.identifier = name;
         this.info = t;
@@ -42,6 +65,7 @@ class LeafNodeSchema {
     }
 }
 exports.LeafNodeSchema = LeafNodeSchema;
+_LeafNodeSchema_initializedData = new WeakMap(), _a = index_js_3.privateDataSymbol;
 /**
  * Wrapper around LeafNodeSchema's constructor that provides the return type that is desired in the package public API.
  */
@@ -55,4 +79,95 @@ exports.numberSchema = makeLeaf("number", index_js_1.ValueSchema.Number);
 exports.booleanSchema = makeLeaf("boolean", index_js_1.ValueSchema.Boolean);
 exports.nullSchema = makeLeaf("null", index_js_1.ValueSchema.Null);
 exports.handleSchema = makeLeaf("handle", index_js_1.ValueSchema.FluidHandle);
+/**
+ * Checks if data might be schema-compatible.
+ *
+ * @returns false if `data` is incompatible with `type` based on a cheap/shallow check.
+ *
+ * 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) {
+    if ((0, index_js_2.isTreeValue)(data)) {
+        return allowsValue(schema, data) ? index_js_3.CompatibilityLevel.Normal : index_js_3.CompatibilityLevel.None;
+    }
+    return index_js_3.CompatibilityLevel.None;
+}
+function allowsValue(schema, value) {
+    if (schema.kind === index_js_3.NodeKind.Leaf) {
+        return (0, index_js_2.valueSchemaAllows)(schema.info, value);
+    }
+    return false;
+}
+/**
+ * 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 leafToFlexContent(data, schema, allowedTypes) {
+    (0, internal_1.assert)(schema.kind === index_js_3.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 mappedValue = mapValueWithFallbacks(data, allowedTypes);
+    const mappedSchema = [...allowedTypes].find((type) => allowsValue(type, mappedValue));
+    (0, internal_1.assert)(mappedSchema !== undefined, 0x84a /* Unsupported schema for provided primitive. */);
+    const result = [
+        {
+            value: mappedValue,
+            type: (0, index_js_4.brand)(mappedSchema.identifier),
+        },
+        new Map(),
+    ];
+    return result;
+}
+exports.leafToFlexContent = leafToFlexContent;
+/**
+ * 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.
+ */
+function mapValueWithFallbacks(value, allowedTypes) {
+    switch (typeof value) {
+        case "number": {
+            if (Object.is(value, -0)) {
+                // Our serialized data format does not support -0.
+                // Map such input to +0.
+                return 0;
+            }
+            else if (!Number.isFinite(value)) {
+                // 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 (allowedTypes.has(exports.nullSchema)) {
+                    return null;
+                }
+                else {
+                    throw new internal_2.UsageError(`Received unsupported numeric value: ${value}.`);
+                }
+            }
+            else {
+                return value;
+            }
+        }
+        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 || (0, internal_3.isFluidHandle)(value)) {
+                return value;
+            }
+        }
+        default:
+            throw new internal_2.UsageError(`Received unsupported leaf value: ${value}.`);
+    }
+}
 //# sourceMappingURL=leafNodeSchema.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"leafNodeSchema.js","sourceRoot":"","sources":["../../src/simple-tree/leafNodeSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAE7D,+CAA+D;AAC/D,4DAIuC;AAEvC,8CAKyB;AAKzB;;;;;;;;GAQG;AACH,MAAa,cAAc;IAUnB,MAAM,CAAC,IAAiC;QAC9C,IAAI,IAAA,yBAAc,EAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACzB,IAAA,iBAAM,EAAC,IAAA,4BAAiB,EAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;YACvE,OAAO,KAAK,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,oBAAoB,CAAC,IAAkB;QAC7C,OAAO,IAAI,CAAC;IACb,CAAC;IAOD,YAAmB,IAAU,EAAE,CAAI;QAxBnB,SAAI,GAAG,mBAAQ,CAAC,IAAI,CAAC;QAErB,4BAAuB,GAAG,IAAa,CAAC;QACxC,eAAU,GAAgC,IAAI,GAAG,EAAE,CAAC;QACpD,+BAA0B,GAA+C,EAAE,CAAC;QAiB5E,aAAQ,GAAuB,EAAE,CAAC;QAIjD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACnB,CAAC;CACD;AAjCD,wCAiCC;AAED;;GAEG;AACH,SAAS,QAAQ,CAChB,IAAU,EACV,CAAI;IAEJ,yFAAyF;IACzF,OAAO,IAAI,cAAc,CAAC,2BAA2B,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AACjE,CAAC;AAsBD,0DAA0D;AAC7C,QAAA,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAE,sBAAW,CAAC,MAAM,CAAC,CAAC;AACtD,QAAA,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAE,sBAAW,CAAC,MAAM,CAAC,CAAC;AACtD,QAAA,aAAa,GAAG,QAAQ,CAAC,SAAS,EAAE,sBAAW,CAAC,OAAO,CAAC,CAAC;AACzD,QAAA,UAAU,GAAG,QAAQ,CAAC,MAAM,EAAE,sBAAW,CAAC,IAAI,CAAC,CAAC;AAChD,QAAA,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAE,sBAAW,CAAC,WAAW,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { type TreeValue, ValueSchema } from \"../core/index.js\";\nimport {\n\ttype FlexTreeNode,\n\tisFlexTreeNode,\n\tvalueSchemaAllows,\n} from \"../feature-libraries/index.js\";\n\nimport {\n\tNodeKind,\n\ttype NormalizedAnnotatedAllowedTypes,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaNonClass,\n} from \"./core/index.js\";\nimport type { NodeSchemaMetadata, TreeLeafValue } from \"./schemaTypes.js\";\nimport type { SimpleLeafNodeSchema } from \"./simpleSchema.js\";\nimport type { JsonCompatibleReadOnlyObject } from \"../util/index.js\";\n\n/**\n * Instances of this class are schema for leaf nodes.\n * @remarks\n * Unlike other schema, leaf schema are class instances instead of classes themselves.\n * This is because the instance type (the tree node type) for leaves are not objects,\n * so those instances can't be instances of a schema based class.\n * @privateRemarks\n * This class refers to the underlying flex tree schema in its constructor, so this class can't be included in the package API.\n */\nexport class LeafNodeSchema<Name extends string, const T extends ValueSchema>\n\timplements TreeNodeSchemaNonClass<Name, NodeKind.Leaf, TreeValue<T>, TreeValue<T>>\n{\n\tpublic readonly identifier: Name;\n\tpublic readonly kind = NodeKind.Leaf;\n\tpublic readonly info: T;\n\tpublic readonly implicitlyConstructable = true as const;\n\tpublic readonly childTypes: ReadonlySet<TreeNodeSchema> = new Set();\n\tpublic readonly childAnnotatedAllowedTypes: readonly NormalizedAnnotatedAllowedTypes[] = [];\n\n\tpublic create(data: TreeValue<T> | FlexTreeNode): TreeValue<T> {\n\t\tif (isFlexTreeNode(data)) {\n\t\t\tconst value = data.value;\n\t\t\tassert(valueSchemaAllows(this.info, value), 0x916 /* invalid value */);\n\t\t\treturn value;\n\t\t}\n\t\treturn data;\n\t}\n\n\tpublic createFromInsertable(data: TreeValue<T>): TreeValue<T> {\n\t\treturn data;\n\t}\n\n\tpublic readonly leafKind: ValueSchema;\n\n\tpublic readonly metadata: NodeSchemaMetadata = {};\n\tpublic readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;\n\n\tpublic constructor(name: Name, t: T) {\n\t\tthis.identifier = name;\n\t\tthis.info = t;\n\t\tthis.leafKind = t;\n\t}\n}\n\n/**\n * Wrapper around LeafNodeSchema's constructor that provides the return type that is desired in the package public API.\n */\nfunction makeLeaf<Name extends string, const T extends ValueSchema>(\n\tname: Name,\n\tt: T,\n): LeafSchema<Name, TreeValue<T>> & SimpleLeafNodeSchema {\n\t// Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation\n\treturn new LeafNodeSchema(`com.fluidframework.leaf.${name}`, t);\n}\n\n/**\n * A {@link TreeNodeSchema} for a {@link TreeLeafValue}.\n * @remarks\n * This is just a more specific alias for a particular {@link TreeNodeSchemaNonClass}.\n * It only exists to make the API (particularly errors, IntelliSense, and generated .d.ts files) more readable.\n *\n * See {@link SchemaFactory} and its various properties for actual leaf schema objects.\n * @privateRemarks\n * This is an interface so its name will show up in things like type errors instead of the fully expanded TreeNodeSchemaNonClass.\n * @system @sealed @public\n */\nexport interface LeafSchema<Name extends string, T extends TreeLeafValue>\n\textends TreeNodeSchemaNonClass<\n\t\t`com.fluidframework.leaf.${Name}`,\n\t\tNodeKind.Leaf,\n\t\t/* TNode */ T,\n\t\t/* TInsertable */ T,\n\t\t/* ImplicitlyConstructable */ true\n\t> {}\n\n// Leaf schema shared between all SchemaFactory instances.\nexport const stringSchema = makeLeaf(\"string\", ValueSchema.String);\nexport const numberSchema = makeLeaf(\"number\", ValueSchema.Number);\nexport const booleanSchema = makeLeaf(\"boolean\", ValueSchema.Boolean);\nexport const nullSchema = makeLeaf(\"null\", ValueSchema.Null);\nexport const handleSchema = makeLeaf(\"handle\", ValueSchema.FluidHandle);\n"]}
+{"version":3,"file":"leafNodeSchema.js","sourceRoot":"","sources":["../../src/simple-tree/leafNodeSchema.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 } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\n\nimport { type TreeValue, ValueSchema } from \"../core/index.js\";\nimport {\n\ttype FlexTreeNode,\n\tisFlexTreeNode,\n\tisTreeValue,\n\tvalueSchemaAllows,\n} from \"../feature-libraries/index.js\";\n\nimport {\n\tNodeKind,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaNonClass,\n\ttype NodeSchemaMetadata,\n\ttype TreeLeafValue,\n\ttype TreeNodeSchemaCorePrivate,\n\ttype TreeNodeSchemaPrivateData,\n\tprivateDataSymbol,\n\ttype TreeNodeSchemaInitializedData,\n\tCompatibilityLevel,\n\ttype FlexContent,\n} from \"./core/index.js\";\nimport type { SimpleLeafNodeSchema } from \"./simpleSchema.js\";\nimport { brand, type JsonCompatibleReadOnlyObject } from \"../util/index.js\";\nimport { getTreeNodeSchemaInitializedData } from \"./createContext.js\";\nimport type { FactoryContent } from \"./unhydratedFlexTreeFromInsertable.js\";\n\n/**\n * Instances of this class are schema for leaf nodes.\n * @remarks\n * Unlike other schema, leaf schema are class instances instead of classes themselves.\n * This is because the instance type (the tree node type) for leaves are not objects,\n * so those instances can't be instances of a schema based class.\n * @privateRemarks\n * This class refers to the underlying flex tree schema in its constructor, so this class can't be included in the package API.\n */\nexport class LeafNodeSchema<Name extends string, const T extends ValueSchema>\n\timplements\n\t\tTreeNodeSchemaNonClass<Name, NodeKind.Leaf, TreeValue<T>, TreeValue<T>>,\n\t\tSimpleLeafNodeSchema,\n\t\tTreeNodeSchemaCorePrivate\n{\n\tpublic readonly identifier: Name;\n\tpublic readonly kind = NodeKind.Leaf;\n\tpublic readonly info: T;\n\tpublic readonly implicitlyConstructable = true as const;\n\tpublic readonly childTypes: ReadonlySet<TreeNodeSchema> = new Set();\n\tpublic readonly [privateDataSymbol]: TreeNodeSchemaPrivateData = {\n\t\tidempotentInitialize: () =>\n\t\t\t(this.#initializedData ??= getTreeNodeSchemaInitializedData(this, {\n\t\t\t\tshallowCompatibilityTest: (data: FactoryContent): CompatibilityLevel =>\n\t\t\t\t\tshallowCompatibilityTest(this, data),\n\t\t\t\ttoFlexContent: (\n\t\t\t\t\tdata: FactoryContent,\n\t\t\t\t\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\t\t\t\t): FlexContent => leafToFlexContent(data, this, allowedTypes),\n\t\t\t})),\n\t\tchildAnnotatedAllowedTypes: [],\n\t};\n\t#initializedData: TreeNodeSchemaInitializedData | undefined;\n\n\tpublic create(data: TreeValue<T> | FlexTreeNode): TreeValue<T> {\n\t\tif (isFlexTreeNode(data)) {\n\t\t\tconst value = data.value;\n\t\t\tassert(valueSchemaAllows(this.info, value), 0x916 /* invalid value */);\n\t\t\treturn value;\n\t\t}\n\t\treturn data;\n\t}\n\n\tpublic createFromInsertable(data: TreeValue<T>): TreeValue<T> {\n\t\treturn data;\n\t}\n\n\tpublic readonly leafKind: ValueSchema;\n\n\tpublic readonly metadata: NodeSchemaMetadata = {};\n\tpublic readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;\n\n\tpublic constructor(name: Name, t: T) {\n\t\tthis.identifier = name;\n\t\tthis.info = t;\n\t\tthis.leafKind = t;\n\t}\n}\n\n/**\n * Wrapper around LeafNodeSchema's constructor that provides the return type that is desired in the package public API.\n */\nfunction makeLeaf<Name extends string, const T extends ValueSchema>(\n\tname: Name,\n\tt: T,\n): LeafSchema<Name, TreeValue<T>> & SimpleLeafNodeSchema {\n\t// Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation\n\treturn new LeafNodeSchema(`com.fluidframework.leaf.${name}`, t);\n}\n\n/**\n * A {@link TreeNodeSchema} for a {@link TreeLeafValue}.\n * @remarks\n * This is just a more specific alias for a particular {@link TreeNodeSchemaNonClass}.\n * It only exists to make the API (particularly errors, IntelliSense, and generated .d.ts files) more readable.\n *\n * See {@link SchemaFactory} and its various properties for actual leaf schema objects.\n * @privateRemarks\n * This is an interface so its name will show up in things like type errors instead of the fully expanded TreeNodeSchemaNonClass.\n * @system @sealed @public\n */\nexport interface LeafSchema<Name extends string, T extends TreeLeafValue>\n\textends TreeNodeSchemaNonClass<\n\t\t`com.fluidframework.leaf.${Name}`,\n\t\tNodeKind.Leaf,\n\t\t/* TNode */ T,\n\t\t/* TInsertable */ T,\n\t\t/* ImplicitlyConstructable */ true\n\t> {}\n\n// Leaf schema shared between all SchemaFactory instances.\nexport const stringSchema = makeLeaf(\"string\", ValueSchema.String);\nexport const numberSchema = makeLeaf(\"number\", ValueSchema.Number);\nexport const booleanSchema = makeLeaf(\"boolean\", ValueSchema.Boolean);\nexport const nullSchema = makeLeaf(\"null\", ValueSchema.Null);\nexport const handleSchema = makeLeaf(\"handle\", ValueSchema.FluidHandle);\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\tif (isTreeValue(data)) {\n\t\treturn allowsValue(schema, data) ? CompatibilityLevel.Normal : CompatibilityLevel.None;\n\t}\n\n\treturn CompatibilityLevel.None;\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 * 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 */\nexport function 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 = [...allowedTypes].find((type) => allowsValue(type, mappedValue));\n\n\tassert(mappedSchema !== undefined, 0x84a /* Unsupported schema for provided primitive. */);\n\n\tconst result: FlexContent = [\n\t\t{\n\t\t\tvalue: mappedValue,\n\t\t\ttype: brand(mappedSchema.identifier),\n\t\t},\n\t\tnew Map(),\n\t];\n\n\treturn result;\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"]}

package/dist/simple-tree/node-kinds/array/arrayNode.d.ts

@@ -2,11 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { type ImplicitAllowedTypes, type ImplicitAnnotatedAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type NodeSchemaMetadata, type TreeLeafValue, type TreeNodeFromImplicitAllowedTypes } from "../../schemaTypes.js";
-import { type WithType, NodeKind, type TreeNode } from "../../core/index.js";
+import { type WithType, NodeKind, type TreeNode, type ImplicitAllowedTypes, type ImplicitAnnotatedAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type NodeSchemaMetadata, type TreeLeafValue, type TreeNodeFromImplicitAllowedTypes, type TreeNodeSchemaCorePrivate } from "../../core/index.js";
 import type { System_Unsafe } from "../../api/index.js";
 import type { ArrayNodeCustomizableSchema, ArrayNodePojoEmulationSchema } from "./arrayNodeTypes.js";
-import type { JsonCompatibleReadOnlyObject } from "../../../util/index.js";
+import { type JsonCompatibleReadOnlyObject } from "../../../util/index.js";
 /**
  * A covariant base type for {@link (TreeArrayNode:interface)}.
  *
@@ -377,5 +376,5 @@ export declare function asIndex(key: string | symbol, exclusiveMax: number): num
  * @param name - Unique identifier for this schema including the factory's scope.
  * @param persistedMetadata - Optional persisted metadata for the object node schema.
  */
-export declare function arraySchema<TName extends string, const T extends ImplicitAnnotatedAllowedTypes, const ImplicitlyConstructable extends boolean, const TCustomMetadata = unknown>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean, metadata?: NodeSchemaMetadata<TCustomMetadata>, persistedMetadata?: JsonCompatibleReadOnlyObject | undefined): ArrayNodeCustomizableSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata>;
+export declare function arraySchema<TName extends string, const T extends ImplicitAnnotatedAllowedTypes, const ImplicitlyConstructable extends boolean, const TCustomMetadata = unknown>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean, metadata?: NodeSchemaMetadata<TCustomMetadata>, persistedMetadata?: JsonCompatibleReadOnlyObject | undefined): ArrayNodeCustomizableSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & TreeNodeSchemaCorePrivate<string, NodeKind, never, boolean, unknown, unknown>;
 //# sourceMappingURL=arrayNode.d.ts.map

package/dist/simple-tree/node-kinds/array/arrayNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../../../src/simple-tree/node-kinds/array/arrayNode.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../../../src/simple-tree/node-kinds/array/arrayNode.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/node-kinds/array/arrayNode.js

@@ -14,12 +14,13 @@ exports.arraySchema = exports.asIndex = exports.IterableTreeArrayContent = expor
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../../../core/index.js");
-const schemaTypes_js_1 = require("../../schemaTypes.js");
-const index_js_2 = require("../../core/index.js");
+const index_js_2 = require("../../../feature-libraries/index.js");
+const index_js_3 = require("../../core/index.js");
 const unhydratedFlexTreeFromInsertable_js_1 = require("../../unhydratedFlexTreeFromInsertable.js");
 const prepareForInsertion_js_1 = require("../../prepareForInsertion.js");
-const treeNodeValid_js_1 = require("../../treeNodeValid.js");
 const createContext_js_1 = require("../../createContext.js");
+const index_js_4 = require("../../../util/index.js");
+const leafNodeSchema_js_1 = require("../../leafNodeSchema.js");
 /**
  * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
  * @public
@@ -66,7 +67,7 @@ exports.IterableTreeArrayContent = IterableTreeArrayContent;
  * Given a array node proxy, returns its underlying LazySequence field.
  */
 function getSequenceField(arrayNode) {
-    return (0, index_js_2.getOrCreateInnerNode)(arrayNode).getBoxed(index_js_1.EmptyKey);
+    return (0, index_js_3.getOrCreateInnerNode)(arrayNode).getBoxed(index_js_1.EmptyKey);
 }
 // For compatibility, we are initially implement 'readonly T[]' by applying the Array.prototype methods
 // to the array node proxy.  Over time, we should replace these with efficient implementations on LazySequence
@@ -118,7 +119,7 @@ const TreeNodeWithArrayFeatures = (() => {
     /**
      * {@link TreeNodeValid}, but modified to add members from Array.prototype named in {@link arrayPrototypeKeys}.
      */
-    class TreeNodeWithArrayFeaturesUntyped extends treeNodeValid_js_1.TreeNodeValid {
+    class TreeNodeWithArrayFeaturesUntyped extends index_js_3.TreeNodeValid {
     }
     // Modify TreeNodeWithArrayFeaturesUntyped to add the members from Array.prototype
     arrayPrototypeKeys.forEach((key) => {
@@ -168,7 +169,7 @@ exports.asIndex = asIndex;
 function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTarget) {
     // To satisfy 'deepEquals' level scrutiny, the target of the proxy must be an array literal in order
     // to pass 'Object.getPrototypeOf'.  It also satisfies 'Array.isArray' and 'Object.prototype.toString'
-    // requirements without use of Array[Symbol.species], which is potentially on a path ot deprecation.
+    // requirements without use of Array[Symbol.species], which is potentially on a path to deprecation.
     const proxy = new Proxy(proxyTarget, {
         get: (target, key, receiver) => {
             const field = getSequenceField(receiver);
@@ -177,6 +178,11 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
                 if (key === "length") {
                     return field.length;
                 }
+                // In NodeJS 22, assert.strict.deepEqual started special casing well known constructors like Array.
+                // That made this necessary, ensuring that in POJO mode, TreeArrayNode are still deepEqual to arrays.
+                if (key === "constructor") {
+                    return proxyTarget.constructor;
+                }
                 // Pass the proxy as the receiver here, so that any methods on
                 // the prototype receive `proxy` as `this`.
                 return Reflect.get(dispatchTarget, key, receiver);
@@ -184,7 +190,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
             const maybeContent = field.at(maybeIndex);
             return maybeContent === undefined
                 ? undefined
-                : (0, index_js_2.getOrCreateNodeFromInnerUnboxedNode)(maybeContent);
+                : (0, index_js_3.getOrCreateNodeFromInnerUnboxedNode)(maybeContent);
         },
         set: (target, key, newValue, receiver) => {
             if (key === "length") {
@@ -235,7 +241,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
                 // To satisfy 'deepEquals' level scrutiny, the property descriptor for indexed properties must
                 // be a simple value property (as opposed to using getter) and declared writable/enumerable/configurable.
                 return {
-                    value: val === undefined ? undefined : (0, index_js_2.getOrCreateNodeFromInnerUnboxedNode)(val),
+                    value: val === undefined ? undefined : (0, index_js_3.getOrCreateNodeFromInnerUnboxedNode)(val),
                     writable: true, // For MVP, setting indexed properties is reported as allowed here (for deep equals compatibility noted above), but not actually supported.
                     enumerable: true,
                     configurable: true,
@@ -300,7 +306,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         if (val === undefined) {
             return val;
         }
-        return (0, index_js_2.getOrCreateNodeFromInnerNode)(val);
+        return (0, index_js_3.getOrCreateNodeFromInnerNode)(val);
     }
     insertAt(index, ...value) {
         const field = getSequenceField(this);
@@ -370,7 +376,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         if (sourceField !== destinationField) {
             for (let i = sourceStart; i < sourceEnd; i++) {
                 const sourceNode = sourceField.boxedAt(i) ?? (0, internal_1.oob)();
-                const sourceSchema = (0, index_js_2.getSimpleNodeSchemaFromInnerNode)(sourceNode);
+                const sourceSchema = (0, index_js_3.getSimpleNodeSchemaFromInnerNode)(sourceNode);
                 if (!destinationSchema.has(sourceSchema)) {
                     throw new internal_2.UsageError("Type in source sequence is not allowed in destination.");
                 }
@@ -378,7 +384,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         }
         const movedCount = sourceEnd - sourceStart;
         if (!destinationField.context.isHydrated()) {
-            if (!(sourceField instanceof index_js_2.UnhydratedSequenceField)) {
+            if (!(sourceField instanceof index_js_3.UnhydratedSequenceField)) {
                 throw new internal_2.UsageError("Cannot move elements from a hydrated array to an unhydrated array.");
             }
             if (sourceField.context.isHydrated()) {
@@ -402,10 +408,10 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         }
     }
     values() {
-        return this.generateValues((0, index_js_2.getKernel)(this).generationNumber);
+        return this.generateValues((0, index_js_3.getKernel)(this).generationNumber);
     }
     *generateValues(initialLastUpdatedStamp) {
-        const kernel = (0, index_js_2.getKernel)(this);
+        const kernel = (0, index_js_3.getKernel)(this);
         if (initialLastUpdatedStamp !== kernel.generationNumber) {
             throw new internal_2.UsageError(`Concurrent editing and iteration is not allowed.`);
         }
@@ -417,7 +423,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         }
     }
 }
-CustomArrayNodeBase.kind = index_js_2.NodeKind.Array;
+CustomArrayNodeBase.kind = index_js_3.NodeKind.Array;
 /**
  * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
  *
@@ -426,11 +432,10 @@ CustomArrayNodeBase.kind = index_js_2.NodeKind.Array;
  */
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function arraySchema(identifier, info, implicitlyConstructable, customizable, metadata, persistedMetadata) {
-    const unannotatedTypes = (0, schemaTypes_js_1.unannotateImplicitAllowedTypes)(info);
-    const lazyChildTypes = new internal_1.Lazy(() => (0, schemaTypes_js_1.normalizeAllowedTypes)(unannotatedTypes));
-    const lazyAnnotatedTypes = new internal_1.Lazy(() => [(0, schemaTypes_js_1.normalizeAnnotatedAllowedTypes)(info)]);
+    const unannotatedTypes = (0, index_js_3.unannotateImplicitAllowedTypes)(info);
+    const lazyChildTypes = new internal_1.Lazy(() => (0, index_js_3.normalizeAllowedTypes)(unannotatedTypes));
     const lazyAllowedTypesIdentifiers = new internal_1.Lazy(() => new Set([...lazyChildTypes.value].map((type) => type.identifier)));
-    let unhydratedContext;
+    let privateData;
     // This class returns a proxy from its constructor to handle numeric indexing.
     // Alternatively it could extend a normal class which gets tons of numeric properties added.
     class Schema extends CustomArrayNodeBase {
@@ -455,8 +460,6 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable, me
             return lazyAllowedTypesIdentifiers.value;
         }
         static oneTimeSetup() {
-            const schema = this;
-            unhydratedContext = (0, createContext_js_1.getUnhydratedContext)(schema);
             // First run, do extra validation.
             // TODO: provide a way for TreeConfiguration to trigger this same validation to ensure it gets run early.
             // Scan for shadowing inherited members which won't work, but stop scan early to allow shadowing built in (which seems to work ok).
@@ -478,19 +481,20 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable, me
                     prototype = Reflect.getPrototypeOf(prototype);
                 }
             }
-            return unhydratedContext;
+            const schema = this;
+            return (0, createContext_js_1.getTreeNodeSchemaInitializedData)(this, {
+                shallowCompatibilityTest: (data) => shallowCompatibilityTest(data, schema),
+                toFlexContent: (data, allowedTypes) => arrayToFlexContent(data, schema),
+            });
         }
         static get childTypes() {
             return lazyChildTypes.value;
         }
-        static get childAnnotatedAllowedTypes() {
-            return lazyAnnotatedTypes.value;
-        }
         // eslint-disable-next-line import/no-deprecated
-        get [index_js_2.typeNameSymbol]() {
+        get [index_js_3.typeNameSymbol]() {
             return identifier;
         }
-        get [index_js_2.typeSchemaSymbol]() {
+        get [index_js_3.typeSchemaSymbol]() {
             return Schema.constructorCached?.constructor;
         }
         get simpleSchema() {
@@ -499,6 +503,9 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable, me
         get allowedTypes() {
             return lazyChildTypes.value;
         }
+        static get [index_js_3.privateDataSymbol]() {
+            return (privateData ??= (0, index_js_3.createTreeNodeSchemaPrivateData)(this, [info]));
+        }
     }
     Schema.constructorCached = undefined;
     Schema.identifier = identifier;
@@ -541,4 +548,68 @@ function validateIndexRange(startIndex, endIndex, array, methodName) {
         throw new internal_2.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
     }
 }
+/**
+ * Transforms data for a child of an array.
+ * @param child - The tree data to be transformed.
+ * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
+ */
+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;
+    if (child === undefined) {
+        if (allowedTypes.has(leafNodeSchema_js_1.nullSchema)) {
+            childWithFallback = null;
+        }
+        else {
+            throw new TypeError(`Received unsupported array entry value: ${child}.`);
+        }
+    }
+    return (0, unhydratedFlexTreeFromInsertable_js_1.unhydratedFlexTreeFromInsertableNode)(childWithFallback, allowedTypes);
+}
+/**
+ * {@link TreeNodeSchemaInitializedData.toFlexContent} for Array nodes.
+ *
+ * @param data - The tree data to be transformed. Must be an iterable.
+ * @param schema - The schema to comply with.
+ */
+function arrayToFlexContent(data, schema) {
+    if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
+        throw new internal_2.UsageError(`Input data is incompatible with Array schema: ${data}`);
+    }
+    const allowedChildTypes = (0, index_js_3.normalizeAllowedTypes)(schema.info);
+    const mappedData = Array.from(data, (child) => arrayChildToFlexTree(child, allowedChildTypes));
+    const context = (0, createContext_js_1.getUnhydratedContext)(schema).flexContext;
+    // Array nodes have a single `EmptyKey` field:
+    const fieldsEntries = mappedData.length === 0
+        ? []
+        : [
+            [
+                index_js_1.EmptyKey,
+                new index_js_3.UnhydratedSequenceField(context, index_js_2.FieldKinds.sequence.identifier, index_js_1.EmptyKey, mappedData),
+            ],
+        ];
+    return [
+        {
+            type: (0, index_js_4.brand)(schema.identifier),
+        },
+        new Map(fieldsEntries),
+    ];
+}
+/**
+ * {@link TreeNodeSchemaInitializedData.shallowCompatibilityTest} for Array nodes.
+ */
+function shallowCompatibilityTest(data, schema) {
+    if ((0, index_js_2.isTreeValue)(data)) {
+        return index_js_3.CompatibilityLevel.None;
+    }
+    if (data instanceof Map) {
+        // Maps are iterable, so type checking does allow constructing an ArrayNode from a map if the ArrayNode's type is an array that includes the key and value types of the map.
+        return index_js_3.CompatibilityLevel.Low;
+    }
+    if (Symbol.iterator in data) {
+        return index_js_3.CompatibilityLevel.Normal;
+    }
+    return index_js_3.CompatibilityLevel.None;
+}
 //# sourceMappingURL=arrayNode.js.map