@fluidframework/tree 2.30.0 → 2.31.0

package/lib/simple-tree/api/viewSchemaToSimpleSchema.js

@@ -3,175 +3,98 @@
  * Licensed under the MIT License.
  */
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import { normalizeFieldSchema, } from "../schemaTypes.js";
-import { copyProperty, getOrCreate } from "../../util/index.js";
-import { isObjectNodeSchema } from "../objectNodeTypes.js";
+import { normalizeFieldSchema } from "../schemaTypes.js";
+import { ObjectNodeSchema } from "../objectNodeTypes.js";
 import { NodeKind } from "../core/index.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
+import { ArrayNodeSchema } from "../arrayNodeTypes.js";
+import { LeafNodeSchema } from "../leafNodeSchema.js";
+import { MapNodeSchema } from "../mapNodeTypes.js";
 /**
- * Converts a "view" schema to a "simple" schema representation.
+ * Converts an {@link ImplicitFieldSchema} to a "simple" schema representation.
+ *
+ * @param schema - The schema to convert
+ * @param copySchemaObjects - If true, TreeNodeSchema and FieldSchema are copied into plain JavaScript objects. Either way, custom metadata is referenced and not copied.
+ *
+ * @remarks
+ * Given that the Schema types used in {@link ImplicitFieldSchema} already implement the {@link SimpleNodeSchema} interfaces, there are limited use-cases for this function.
+ * One possible use-case is converting schema to a more serialization friendly format.
+ * This format however is not JSON compatible due to use of Maps and Sets,
+ * but it it does not rely on cyclic object references for handling recursive schema and instead uses the `definitions` map.
+ *
+ * @privateRemarks
+ * TODO: once SimpleTreeSchema is stable, {@link TreeViewConfiguration} could implement {@link SimpleTreeSchema} directly.
+ * That would provide the non-copying alternative that could expose the value type of the definitions map as {@link TreeNodeSchema}.
  */
-export function toSimpleTreeSchema(schema) {
+export function toSimpleTreeSchema(schema, copySchemaObjects) {
     const normalizedSchema = normalizeFieldSchema(schema);
-    const allowedTypes = allowedTypesFromFieldSchema(normalizedSchema);
     const definitions = new Map();
-    populateSchemaDefinitionsForField(normalizedSchema, definitions);
-    const output = {
+    walkFieldSchema(normalizedSchema, {
+        node: (nodeSchema) => {
+            // The set of node kinds is extensible, but the typing of SimpleNodeSchema is not, so we need to check that the schema is one of the known kinds.
+            assert(nodeSchema instanceof ArrayNodeSchema ||
+                nodeSchema instanceof MapNodeSchema ||
+                nodeSchema instanceof LeafNodeSchema ||
+                nodeSchema instanceof ObjectNodeSchema, 0xb60 /* Invalid schema */);
+            const outSchema = copySchemaObjects ? copySimpleNodeSchema(nodeSchema) : nodeSchema;
+            definitions.set(nodeSchema.identifier, outSchema);
+        },
+    });
+    return {
         kind: normalizedSchema.kind,
-        allowedTypes,
+        allowedTypesIdentifiers: normalizedSchema.allowedTypesIdentifiers,
         definitions,
+        metadata: normalizedSchema.metadata,
     };
-    copyProperty(normalizedSchema, "metadata", output);
-    return output;
 }
 /**
- * Cache in which the results of {@link toSimpleNodeSchema} are saved.
- */
-const simpleNodeSchemaCache = new WeakMap();
-/**
- * Creates a {@link SimpleNodeSchema} from a {@link TreeNodeSchema}.
+ * Copies a {@link SimpleNodeSchema} into a new plain JavaScript object.
  *
  * @remarks Caches the result on the input schema for future calls.
  */
-function toSimpleNodeSchema(schema) {
-    return getOrCreate(simpleNodeSchemaCache, schema, () => {
-        const kind = schema.kind;
-        switch (kind) {
-            case NodeKind.Leaf: {
-                return leafSchemaToSimpleSchema(schema);
-            }
-            case NodeKind.Map: {
-                return mapSchemaToSimpleSchema(schema);
-            }
-            case NodeKind.Array: {
-                return arraySchemaToSimpleSchema(schema);
-            }
-            case NodeKind.Object: {
-                assert(isObjectNodeSchema(schema), 0xa06 /* Expected object schema */);
-                return objectSchemaToSimpleSchema(schema);
-            }
-            default: {
-                unreachableCase(kind);
-            }
-        }
-    });
+function copySimpleNodeSchema(schema) {
+    const kind = schema.kind;
+    switch (kind) {
+        case NodeKind.Leaf:
+            return copySimpleLeafSchema(schema);
+        case NodeKind.Array:
+        case NodeKind.Map:
+            return copySimpleMapOrArraySchema(schema);
+        case NodeKind.Object:
+            return copySimpleObjectSchema(schema);
+        default:
+            unreachableCase(kind);
+    }
 }
-// TODO: Use a stronger type for leaf schemas once one is available (see object schema handler for an example).
-function leafSchemaToSimpleSchema(schema) {
+function copySimpleLeafSchema(schema) {
     return {
         kind: NodeKind.Leaf,
-        leafKind: schema.info,
+        leafKind: schema.leafKind,
+        metadata: schema.metadata,
     };
 }
-// TODO: Use a stronger type for array schemas once one is available (see object schema handler for an example).
-function arraySchemaToSimpleSchema(schema) {
-    const fieldSchema = normalizeFieldSchema(schema.info);
-    const allowedTypes = allowedTypesFromFieldSchema(fieldSchema);
-    const output = {
-        kind: NodeKind.Array,
-        allowedTypes,
-    };
-    copyProperty(schema, "metadata", output);
-    return output;
-}
-// TODO: Use a stronger type for map schemas once one is available (see object schema handler for an example).
-function mapSchemaToSimpleSchema(schema) {
-    const fieldSchema = normalizeFieldSchema(schema.info);
-    const allowedTypes = allowedTypesFromFieldSchema(fieldSchema);
-    const output = {
-        kind: NodeKind.Map,
-        allowedTypes,
+function copySimpleMapOrArraySchema(schema) {
+    return {
+        kind: schema.kind,
+        allowedTypesIdentifiers: schema.allowedTypesIdentifiers,
+        metadata: schema.metadata,
     };
-    copyProperty(schema, "metadata", output);
-    return output;
 }
-function objectSchemaToSimpleSchema(schema) {
-    const fields = {};
-    for (const [key, field] of schema.fields) {
-        fields[key] = fieldSchemaToSimpleSchema(field);
+function copySimpleObjectSchema(schema) {
+    const fields = new Map();
+    for (const [propertyKey, field] of schema.fields) {
+        // field already is a SimpleObjectFieldSchema, but copy the subset of the properties needed by this interface to get a clean simple object.
+        fields.set(propertyKey, {
+            kind: field.kind,
+            allowedTypesIdentifiers: field.allowedTypesIdentifiers,
+            metadata: field.metadata,
+            storedKey: field.storedKey,
+        });
     }
-    const output = {
+    return {
         kind: NodeKind.Object,
         fields,
+        metadata: schema.metadata,
     };
-    copyProperty(schema, "metadata", output);
-    return output;
-}
-/**
- * Private symbol under which the results of {@link toSimpleNodeSchema} are cached on an input {@link TreeNodeSchema}.
- */
-const simpleFieldSchemaCacheSymbol = Symbol("simpleFieldSchemaCache");
-function fieldSchemaToSimpleSchema(schema) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    if (schema[simpleFieldSchemaCacheSymbol] !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return schema[simpleFieldSchemaCacheSymbol];
-    }
-    const allowedTypes = allowedTypesFromFieldSchema(schema);
-    const result = {
-        kind: schema.kind,
-        allowedTypes,
-    };
-    copyProperty(schema, "metadata", result);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    schema[simpleFieldSchemaCacheSymbol] = result;
-    return result;
-}
-function allowedTypesFromFieldSchema(schema) {
-    const allowedTypes = new Set();
-    for (const type of schema.allowedTypeSet) {
-        allowedTypes.add(type.identifier);
-    }
-    return allowedTypes;
-}
-/**
- * Recursively populates `definitions` by walking the input field schema tree.
- */
-function populateSchemaDefinitionsForField(schema, definitions) {
-    for (const child of schema.allowedTypeSet) {
-        populateSchemaDefinitionsForNode(child, definitions);
-    }
-}
-/**
- * Recursively populates `definitions` by walking the input node schema tree.
- */
-function populateSchemaDefinitionsForNode(schema, definitions) {
-    if (definitions.has(schema.identifier)) {
-        // If the definition has already been populated, no need to recurse.
-        return;
-    }
-    // Populate definition for this schema
-    definitions.set(schema.identifier, toSimpleNodeSchema(schema));
-    // Recurse into children to populate definitions for them
-    const kind = schema.kind;
-    switch (kind) {
-        case NodeKind.Leaf: {
-            // Leaf node, so no need to recurse
-            break;
-        }
-        case NodeKind.Map: {
-            // TODO: Utilize a map schema type-guard once one exists (see object case for an example).
-            // Recursively populate definitions for allowed map children
-            const fieldSchema = normalizeFieldSchema(schema.info);
-            populateSchemaDefinitionsForField(fieldSchema, definitions);
-            break;
-        }
-        case NodeKind.Array: {
-            // TODO: Utilize an array schema type-guard once one exists (see object case for an example).
-            // Recursively populate definitions for allowed map children
-            const fieldSchema = normalizeFieldSchema(schema.info);
-            populateSchemaDefinitionsForField(fieldSchema, definitions);
-            break;
-        }
-        case NodeKind.Object: {
-            assert(isObjectNodeSchema(schema), 0xa07 /* Expected object schema */);
-            for (const [, field] of schema.fields) {
-                populateSchemaDefinitionsForField(field, definitions);
-            }
-            break;
-        }
-        default: {
-            unreachableCase(kind);
-        }
-    }
 }
 //# sourceMappingURL=viewSchemaToSimpleSchema.js.map

package/lib/simple-tree/api/viewSchemaToSimpleSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewSchemaToSimpleSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/api/viewSchemaToSimpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EACN,oBAAoB,GAIpB,MAAM,mBAAmB,CAAC;AAW3B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAgB,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAyB,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,QAAQ,EAAuB,MAAM,kBAAkB,CAAC;AAEjE;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAA2B;IAC7D,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAEtD,MAAM,YAAY,GAAG,2BAA2B,CAAC,gBAAgB,CAAC,CAAC;IAEnE,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4B,CAAC;IACxD,iCAAiC,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;IAEjE,MAAM,MAAM,GAA8B;QACzC,IAAI,EAAE,gBAAgB,CAAC,IAAI;QAC3B,YAAY;QACZ,WAAW;KACX,CAAC;IAEF,YAAY,CAAC,gBAAgB,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IACnD,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,qBAAqB,GAAG,IAAI,OAAO,EAAoC,CAAC;AAE9E;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,MAAsB;IACjD,OAAO,WAAW,CAAC,qBAAqB,EAAE,MAAM,EAAE,GAAG,EAAE;QACtD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACzB,QAAQ,IAAI,EAAE,CAAC;YACd,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;gBACpB,OAAO,wBAAwB,CAAC,MAAM,CAAC,CAAC;YACzC,CAAC;YACD,KAAK,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;gBACnB,OAAO,uBAAuB,CAAC,MAAM,CAAC,CAAC;YACxC,CAAC;YACD,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;gBACrB,OAAO,yBAAyB,CAAC,MAAM,CAAC,CAAC;YAC1C,CAAC;YACD,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;gBACtB,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBACvE,OAAO,0BAA0B,CAAC,MAAM,CAAC,CAAC;YAC3C,CAAC;YACD,OAAO,CAAC,CAAC,CAAC;gBACT,eAAe,CAAC,IAAI,CAAC,CAAC;YACvB,CAAC;QACF,CAAC;IACF,CAAC,CAAC,CAAC;AACJ,CAAC;AAED,+GAA+G;AAC/G,SAAS,wBAAwB,CAAC,MAAsB;IACvD,OAAO;QACN,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,QAAQ,EAAE,MAAM,CAAC,IAAmB;KACpC,CAAC;AACH,CAAC;AAED,gHAAgH;AAChH,SAAS,yBAAyB,CAAC,MAAsB;IACxD,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAA4B,CAAC,CAAC;IAC9E,MAAM,YAAY,GAAG,2BAA2B,CAAC,WAAW,CAAC,CAAC;IAC9D,MAAM,MAAM,GAAmC;QAC9C,IAAI,EAAE,QAAQ,CAAC,KAAK;QACpB,YAAY;KACZ,CAAC;IAEF,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAEzC,OAAO,MAAM,CAAC;AACf,CAAC;AAED,8GAA8G;AAC9G,SAAS,uBAAuB,CAAC,MAAsB;IACtD,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAA4B,CAAC,CAAC;IAC9E,MAAM,YAAY,GAAG,2BAA2B,CAAC,WAAW,CAAC,CAAC;IAC9D,MAAM,MAAM,GAAiC;QAC5C,IAAI,EAAE,QAAQ,CAAC,GAAG;QAClB,YAAY;KACZ,CAAC;IAEF,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAEzC,OAAO,MAAM,CAAC;AACf,CAAC;AAED,SAAS,0BAA0B,CAAC,MAAwB;IAC3D,MAAM,MAAM,GAAsC,EAAE,CAAC;IACrD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAC1C,MAAM,CAAC,GAAG,CAAC,GAAG,yBAAyB,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,MAAM,GAAoC;QAC/C,IAAI,EAAE,QAAQ,CAAC,MAAM;QACrB,MAAM;KACN,CAAC;IAEF,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAEzC,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,4BAA4B,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;AAEtE,SAAS,yBAAyB,CAAC,MAAmB;IACrD,8DAA8D;IAC9D,IAAK,MAAc,CAAC,4BAA4B,CAAC,KAAK,SAAS,EAAE,CAAC;QACjE,8DAA8D;QAC9D,OAAQ,MAAc,CAAC,4BAA4B,CAAsB,CAAC;IAC3E,CAAC;IAED,MAAM,YAAY,GAAG,2BAA2B,CAAC,MAAM,CAAC,CAAC;IACzD,MAAM,MAAM,GAA+B;QAC1C,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,YAAY;KACZ,CAAC;IAEF,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAEzC,8DAA8D;IAC7D,MAAc,CAAC,4BAA4B,CAAC,GAAG,MAAM,CAAC;IAEvD,OAAO,MAAM,CAAC;AACf,CAAC;AAED,SAAS,2BAA2B,CAAC,MAAmB;IACvD,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;QAC1C,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,YAAY,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,SAAS,iCAAiC,CACzC,MAAmB,EACnB,WAA0C;IAE1C,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;QAC3C,gCAAgC,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACtD,CAAC;AACF,CAAC;AAED;;GAEG;AACH,SAAS,gCAAgC,CACxC,MAAsB,EACtB,WAA0C;IAE1C,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;QACxC,oEAAoE;QACpE,OAAO;IACR,CAAC;IAED,sCAAsC;IACtC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;IAE/D,yDAAyD;IACzD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,QAAQ,IAAI,EAAE,CAAC;QACd,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;YACpB,mCAAmC;YACnC,MAAM;QACP,CAAC;QACD,KAAK,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YACnB,0FAA0F;YAE1F,4DAA4D;YAC5D,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAA4B,CAAC,CAAC;YAC9E,iCAAiC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;YAC5D,MAAM;QACP,CAAC;QACD,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YACrB,6FAA6F;YAE7F,4DAA4D;YAC5D,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAA4B,CAAC,CAAC;YAC9E,iCAAiC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;YAC5D,MAAM;QACP,CAAC;QACD,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;YACtB,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,4BAA4B,CAAC,CAAC;YACvE,KAAK,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBACvC,iCAAiC,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YACvD,CAAC;YACD,MAAM;QACP,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACT,eAAe,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;IACF,CAAC;AACF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport {\n\tnormalizeFieldSchema,\n\ttype FieldSchema,\n\ttype ImplicitAllowedTypes,\n\ttype ImplicitFieldSchema,\n} from \"../schemaTypes.js\";\nimport type {\n\tSimpleArrayNodeSchema,\n\tSimpleFieldSchema,\n\tSimpleLeafNodeSchema,\n\tSimpleMapNodeSchema,\n\tSimpleNodeSchema,\n\tSimpleObjectNodeSchema,\n\tSimpleTreeSchema,\n} from \"./simpleSchema.js\";\nimport type { ValueSchema } from \"../../core/index.js\";\nimport { copyProperty, getOrCreate, type Mutable } from \"../../util/index.js\";\nimport { isObjectNodeSchema, type ObjectNodeSchema } from \"../objectNodeTypes.js\";\nimport { NodeKind, type TreeNodeSchema } from \"../core/index.js\";\n\n/**\n * Converts a \"view\" schema to a \"simple\" schema representation.\n */\nexport function toSimpleTreeSchema(schema: ImplicitFieldSchema): SimpleTreeSchema {\n\tconst normalizedSchema = normalizeFieldSchema(schema);\n\n\tconst allowedTypes = allowedTypesFromFieldSchema(normalizedSchema);\n\n\tconst definitions = new Map<string, SimpleNodeSchema>();\n\tpopulateSchemaDefinitionsForField(normalizedSchema, definitions);\n\n\tconst output: Mutable<SimpleTreeSchema> = {\n\t\tkind: normalizedSchema.kind,\n\t\tallowedTypes,\n\t\tdefinitions,\n\t};\n\n\tcopyProperty(normalizedSchema, \"metadata\", output);\n\treturn output;\n}\n\n/**\n * Cache in which the results of {@link toSimpleNodeSchema} are saved.\n */\nconst simpleNodeSchemaCache = new WeakMap<TreeNodeSchema, SimpleNodeSchema>();\n\n/**\n * Creates a {@link SimpleNodeSchema} from a {@link TreeNodeSchema}.\n *\n * @remarks Caches the result on the input schema for future calls.\n */\nfunction toSimpleNodeSchema(schema: TreeNodeSchema): SimpleNodeSchema {\n\treturn getOrCreate(simpleNodeSchemaCache, schema, () => {\n\t\tconst kind = schema.kind;\n\t\tswitch (kind) {\n\t\t\tcase NodeKind.Leaf: {\n\t\t\t\treturn leafSchemaToSimpleSchema(schema);\n\t\t\t}\n\t\t\tcase NodeKind.Map: {\n\t\t\t\treturn mapSchemaToSimpleSchema(schema);\n\t\t\t}\n\t\t\tcase NodeKind.Array: {\n\t\t\t\treturn arraySchemaToSimpleSchema(schema);\n\t\t\t}\n\t\t\tcase NodeKind.Object: {\n\t\t\t\tassert(isObjectNodeSchema(schema), 0xa06 /* Expected object schema */);\n\t\t\t\treturn objectSchemaToSimpleSchema(schema);\n\t\t\t}\n\t\t\tdefault: {\n\t\t\t\tunreachableCase(kind);\n\t\t\t}\n\t\t}\n\t});\n}\n\n// TODO: Use a stronger type for leaf schemas once one is available (see object schema handler for an example).\nfunction leafSchemaToSimpleSchema(schema: TreeNodeSchema): SimpleLeafNodeSchema {\n\treturn {\n\t\tkind: NodeKind.Leaf,\n\t\tleafKind: schema.info as ValueSchema,\n\t};\n}\n\n// TODO: Use a stronger type for array schemas once one is available (see object schema handler for an example).\nfunction arraySchemaToSimpleSchema(schema: TreeNodeSchema): SimpleArrayNodeSchema {\n\tconst fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);\n\tconst allowedTypes = allowedTypesFromFieldSchema(fieldSchema);\n\tconst output: Mutable<SimpleArrayNodeSchema> = {\n\t\tkind: NodeKind.Array,\n\t\tallowedTypes,\n\t};\n\n\tcopyProperty(schema, \"metadata\", output);\n\n\treturn output;\n}\n\n// TODO: Use a stronger type for map schemas once one is available (see object schema handler for an example).\nfunction mapSchemaToSimpleSchema(schema: TreeNodeSchema): SimpleMapNodeSchema {\n\tconst fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);\n\tconst allowedTypes = allowedTypesFromFieldSchema(fieldSchema);\n\tconst output: Mutable<SimpleMapNodeSchema> = {\n\t\tkind: NodeKind.Map,\n\t\tallowedTypes,\n\t};\n\n\tcopyProperty(schema, \"metadata\", output);\n\n\treturn output;\n}\n\nfunction objectSchemaToSimpleSchema(schema: ObjectNodeSchema): SimpleObjectNodeSchema {\n\tconst fields: Record<string, SimpleFieldSchema> = {};\n\tfor (const [key, field] of schema.fields) {\n\t\tfields[key] = fieldSchemaToSimpleSchema(field);\n\t}\n\n\tconst output: Mutable<SimpleObjectNodeSchema> = {\n\t\tkind: NodeKind.Object,\n\t\tfields,\n\t};\n\n\tcopyProperty(schema, \"metadata\", output);\n\n\treturn output;\n}\n\n/**\n * Private symbol under which the results of {@link toSimpleNodeSchema} are cached on an input {@link TreeNodeSchema}.\n */\nconst simpleFieldSchemaCacheSymbol = Symbol(\"simpleFieldSchemaCache\");\n\nfunction fieldSchemaToSimpleSchema(schema: FieldSchema): SimpleFieldSchema {\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tif ((schema as any)[simpleFieldSchemaCacheSymbol] !== undefined) {\n\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\treturn (schema as any)[simpleFieldSchemaCacheSymbol] as SimpleFieldSchema;\n\t}\n\n\tconst allowedTypes = allowedTypesFromFieldSchema(schema);\n\tconst result: Mutable<SimpleFieldSchema> = {\n\t\tkind: schema.kind,\n\t\tallowedTypes,\n\t};\n\n\tcopyProperty(schema, \"metadata\", result);\n\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(schema as any)[simpleFieldSchemaCacheSymbol] = result;\n\n\treturn result;\n}\n\nfunction allowedTypesFromFieldSchema(schema: FieldSchema): Set<string> {\n\tconst allowedTypes = new Set<string>();\n\tfor (const type of schema.allowedTypeSet) {\n\t\tallowedTypes.add(type.identifier);\n\t}\n\treturn allowedTypes;\n}\n\n/**\n * Recursively populates `definitions` by walking the input field schema tree.\n */\nfunction populateSchemaDefinitionsForField(\n\tschema: FieldSchema,\n\tdefinitions: Map<string, SimpleNodeSchema>,\n): void {\n\tfor (const child of schema.allowedTypeSet) {\n\t\tpopulateSchemaDefinitionsForNode(child, definitions);\n\t}\n}\n\n/**\n * Recursively populates `definitions` by walking the input node schema tree.\n */\nfunction populateSchemaDefinitionsForNode(\n\tschema: TreeNodeSchema,\n\tdefinitions: Map<string, SimpleNodeSchema>,\n): void {\n\tif (definitions.has(schema.identifier)) {\n\t\t// If the definition has already been populated, no need to recurse.\n\t\treturn;\n\t}\n\n\t// Populate definition for this schema\n\tdefinitions.set(schema.identifier, toSimpleNodeSchema(schema));\n\n\t// Recurse into children to populate definitions for them\n\tconst kind = schema.kind;\n\tswitch (kind) {\n\t\tcase NodeKind.Leaf: {\n\t\t\t// Leaf node, so no need to recurse\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Map: {\n\t\t\t// TODO: Utilize a map schema type-guard once one exists (see object case for an example).\n\n\t\t\t// Recursively populate definitions for allowed map children\n\t\t\tconst fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);\n\t\t\tpopulateSchemaDefinitionsForField(fieldSchema, definitions);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Array: {\n\t\t\t// TODO: Utilize an array schema type-guard once one exists (see object case for an example).\n\n\t\t\t// Recursively populate definitions for allowed map children\n\t\t\tconst fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);\n\t\t\tpopulateSchemaDefinitionsForField(fieldSchema, definitions);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Object: {\n\t\t\tassert(isObjectNodeSchema(schema), 0xa07 /* Expected object schema */);\n\t\t\tfor (const [, field] of schema.fields) {\n\t\t\t\tpopulateSchemaDefinitionsForField(field, definitions);\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault: {\n\t\t\tunreachableCase(kind);\n\t\t}\n\t}\n}\n"]}
+{"version":3,"file":"viewSchemaToSimpleSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/api/viewSchemaToSimpleSchema.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, unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { normalizeFieldSchema, type ImplicitFieldSchema } from \"../schemaTypes.js\";\nimport type {\n\tSimpleArrayNodeSchema,\n\tSimpleLeafNodeSchema,\n\tSimpleMapNodeSchema,\n\tSimpleNodeSchema,\n\tSimpleObjectFieldSchema,\n\tSimpleObjectNodeSchema,\n\tSimpleTreeSchema,\n} from \"../simpleSchema.js\";\nimport { ObjectNodeSchema } from \"../objectNodeTypes.js\";\nimport { NodeKind } from \"../core/index.js\";\nimport { walkFieldSchema } from \"../walkFieldSchema.js\";\nimport { ArrayNodeSchema } from \"../arrayNodeTypes.js\";\nimport { LeafNodeSchema } from \"../leafNodeSchema.js\";\nimport { MapNodeSchema } from \"../mapNodeTypes.js\";\n\n/**\n * Converts an {@link ImplicitFieldSchema} to a \"simple\" schema representation.\n *\n * @param schema - The schema to convert\n * @param copySchemaObjects - If true, TreeNodeSchema and FieldSchema are copied into plain JavaScript objects. Either way, custom metadata is referenced and not copied.\n *\n * @remarks\n * Given that the Schema types used in {@link ImplicitFieldSchema} already implement the {@link SimpleNodeSchema} interfaces, there are limited use-cases for this function.\n * One possible use-case is converting schema to a more serialization friendly format.\n * This format however is not JSON compatible due to use of Maps and Sets,\n * but it it does not rely on cyclic object references for handling recursive schema and instead uses the `definitions` map.\n *\n * @privateRemarks\n * TODO: once SimpleTreeSchema is stable, {@link TreeViewConfiguration} could implement {@link SimpleTreeSchema} directly.\n * That would provide the non-copying alternative that could expose the value type of the definitions map as {@link TreeNodeSchema}.\n */\nexport function toSimpleTreeSchema(\n\tschema: ImplicitFieldSchema,\n\tcopySchemaObjects: boolean,\n): SimpleTreeSchema {\n\tconst normalizedSchema = normalizeFieldSchema(schema);\n\tconst definitions = new Map<string, SimpleNodeSchema>();\n\twalkFieldSchema(normalizedSchema, {\n\t\tnode: (nodeSchema) => {\n\t\t\t// The set of node kinds is extensible, but the typing of SimpleNodeSchema is not, so we need to check that the schema is one of the known kinds.\n\t\t\tassert(\n\t\t\t\tnodeSchema instanceof ArrayNodeSchema ||\n\t\t\t\t\tnodeSchema instanceof MapNodeSchema ||\n\t\t\t\t\tnodeSchema instanceof LeafNodeSchema ||\n\t\t\t\t\tnodeSchema instanceof ObjectNodeSchema,\n\t\t\t\t0xb60 /* Invalid schema */,\n\t\t\t);\n\t\t\tconst outSchema = copySchemaObjects ? copySimpleNodeSchema(nodeSchema) : nodeSchema;\n\t\t\tdefinitions.set(nodeSchema.identifier, outSchema);\n\t\t},\n\t});\n\n\treturn {\n\t\tkind: normalizedSchema.kind,\n\t\tallowedTypesIdentifiers: normalizedSchema.allowedTypesIdentifiers,\n\t\tdefinitions,\n\t\tmetadata: normalizedSchema.metadata,\n\t};\n}\n\n/**\n * Copies a {@link SimpleNodeSchema} into a new plain JavaScript object.\n *\n * @remarks Caches the result on the input schema for future calls.\n */\nfunction copySimpleNodeSchema(schema: SimpleNodeSchema): SimpleNodeSchema {\n\tconst kind = schema.kind;\n\tswitch (kind) {\n\t\tcase NodeKind.Leaf:\n\t\t\treturn copySimpleLeafSchema(schema);\n\t\tcase NodeKind.Array:\n\t\tcase NodeKind.Map:\n\t\t\treturn copySimpleMapOrArraySchema(schema);\n\t\tcase NodeKind.Object:\n\t\t\treturn copySimpleObjectSchema(schema);\n\t\tdefault:\n\t\t\tunreachableCase(kind);\n\t}\n}\n\nfunction copySimpleLeafSchema(schema: SimpleLeafNodeSchema): SimpleLeafNodeSchema {\n\treturn {\n\t\tkind: NodeKind.Leaf,\n\t\tleafKind: schema.leafKind,\n\t\tmetadata: schema.metadata,\n\t};\n}\n\nfunction copySimpleMapOrArraySchema(\n\tschema: SimpleMapNodeSchema | SimpleArrayNodeSchema,\n): SimpleMapNodeSchema | SimpleArrayNodeSchema {\n\treturn {\n\t\tkind: schema.kind,\n\t\tallowedTypesIdentifiers: schema.allowedTypesIdentifiers,\n\t\tmetadata: schema.metadata,\n\t};\n}\n\nfunction copySimpleObjectSchema(schema: SimpleObjectNodeSchema): SimpleObjectNodeSchema {\n\tconst fields: Map<string, SimpleObjectFieldSchema> = new Map();\n\tfor (const [propertyKey, field] of schema.fields) {\n\t\t// field already is a SimpleObjectFieldSchema, but copy the subset of the properties needed by this interface to get a clean simple object.\n\t\tfields.set(propertyKey, {\n\t\t\tkind: field.kind,\n\t\t\tallowedTypesIdentifiers: field.allowedTypesIdentifiers,\n\t\t\tmetadata: field.metadata,\n\t\t\tstoredKey: field.storedKey,\n\t\t});\n\t}\n\n\treturn {\n\t\tkind: NodeKind.Object,\n\t\tfields,\n\t\tmetadata: schema.metadata,\n\t};\n}\n"]}

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

@@ -3,8 +3,9 @@
  * Licensed under the MIT License.
  */
 import { type ImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type NodeSchemaMetadata, type TreeLeafValue, type TreeNodeFromImplicitAllowedTypes } from "./schemaTypes.js";
-import { type WithType, NodeKind, type TreeNode, type TreeNodeSchemaBoth } from "./core/index.js";
-import type { Unenforced } from "./api/index.js";
+import { type WithType, NodeKind, type TreeNode } from "./core/index.js";
+import type { ImplicitAllowedTypesUnsafe } from "./api/index.js";
+import type { ArrayNodeCustomizableSchema, ArrayNodePojoEmulationSchema } from "./arrayNodeTypes.js";
 /**
  * A covariant base type for {@link (TreeArrayNode:interface)}.
  *
@@ -26,7 +27,7 @@ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends Rea
  *
  * @sealed @public
  */
-export interface TreeArrayNode<TAllowedTypes extends Unenforced<ImplicitAllowedTypes> = ImplicitAllowedTypes, out T = [TAllowedTypes] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TAllowedTypes> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, in TNew = [TAllowedTypes] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes> : InsertableTreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
+export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypesUnsafe = ImplicitAllowedTypes, out T = [TAllowedTypes] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TAllowedTypes> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, in TNew = [TAllowedTypes] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes> : InsertableTreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
     /**
      * Inserts new item(s) at a specified location.
      * @param index - The index at which to insert `value`.
@@ -346,5 +347,5 @@ export declare function asIndex(key: string | symbol, exclusiveMax: number): num
  *
  * @param name - Unique identifier for this schema including the factory's scope.
  */
-export declare function arraySchema<TName extends string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean, const TCustomMetadata = unknown>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean, metadata?: NodeSchemaMetadata<TCustomMetadata>): TreeNodeSchemaBoth<TName, NodeKind.Array, TreeArrayNode<T, [T] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<T> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [T] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<T> : never, ReadonlyArrayNode<TreeNode | TreeLeafValue>> & WithType<TName, NodeKind.Array, unknown>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T, undefined, TCustomMetadata>;
+export declare function arraySchema<TName extends string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean, const TCustomMetadata = unknown>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean, metadata?: NodeSchemaMetadata<TCustomMetadata>): ArrayNodeCustomizableSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata>;
 //# sourceMappingURL=arrayNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/arrayNode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAEN,KAAK,oBAAoB,EACzB,KAAK,0CAA0C,EAC/C,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,gCAAgC,EACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACN,KAAK,QAAQ,EAGb,QAAQ,EACR,KAAK,QAAQ,EAMb,KAAK,kBAAkB,EAIvB,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,GAAG,aAAa,CAClE,SAAQ,aAAa,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;CAAG;AAEzD;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa,CAC7B,aAAa,SAAS,UAAU,CAAC,oBAAoB,CAAC,GAAG,oBAAoB,EAC7E,GAAG,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC,SAAS,CAAC,oBAAoB,CAAC,GACnD,gCAAgC,CAAC,aAAa,CAAC,GAC/C,gCAAgC,CAAC,oBAAoB,CAAC,EACzD,EAAE,CAAC,IAAI,GAAG,CAAC,aAAa,CAAC,SAAS,CAAC,oBAAoB,CAAC,GACrD,0CAA0C,CAAC,aAAa,CAAC,GACzD,0CAA0C,CAAC,oBAAoB,CAAC,EACnE,EAAE,CAAC,SAAS,GAAG,iBAAiB,CAC/B,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,SAAS,CAAC,IAAI,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;IAE5F;;;OAGG;IACH,aAAa,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC,IAAI,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;IAElF;;;OAGG;IACH,WAAW,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC,IAAI,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;IAEhF;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD;;;;OAIG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC;;;;;OAKG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAE1D;;;;OAIG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC;;;;;OAKG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAElF;;;;;;OAMG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/D;;;;;;;;OAQG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAElF;;;;;;OAMG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7D;;;;;;;;OAQG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,gBAAgB,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,gBAAgB,CACf,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,SAAS,GACf,IAAI,CAAC;IAER;;OAEG;IACH,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;IACzB;;;;;;;;;OASG;kCACkB,SAAS,CAAC,CAAC;CACvB,CAAC;AAQX;;;;GAIG;AACH,qBAAa,wBAAwB,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAK1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAA5C,OAAO;IAEP;;OAEG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;CAGvC;AAsND;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAqBtF;AAoYD;;;;GAIG;AAEH,wBAAgB,WAAW,CAC1B,KAAK,SAAS,MAAM,EACpB,KAAK,CAAC,CAAC,SAAS,oBAAoB,EACpC,KAAK,CAAC,uBAAuB,SAAS,OAAO,EAC7C,KAAK,CAAC,eAAe,GAAG,OAAO,EAE/B,UAAU,EAAE,KAAK,EACjB,IAAI,EAAE,CAAC,EACP,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,EAAE,OAAO,EACrB,QAAQ,CAAC,EAAE,kBAAkB,CAAC,eAAe,CAAC,ueAiH9C"}
+{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/arrayNode.ts"],"names":[],"mappings":"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"}

package/lib/simple-tree/arrayNode.js

@@ -8,7 +8,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _CustomArrayNodeBase_instances, _CustomArrayNodeBase_mapTreesFromFieldData;
-import { Lazy, oob } from "@fluidframework/core-utils/internal";
+import { Lazy, oob, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { EmptyKey } from "../core/index.js";
 import { getSchemaAndPolicy, isFlexTreeNode, } from "../feature-libraries/index.js";
@@ -18,7 +18,6 @@ import {
 // eslint-disable-next-line import/no-deprecated
 typeNameSymbol, NodeKind, typeSchemaSymbol, getOrCreateNodeFromInnerNode, getSimpleNodeSchemaFromInnerNode, getOrCreateInnerNode, } from "./core/index.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { fail } from "../util/index.js";
 import { getKernel, UnhydratedFlexTreeNode, UnhydratedTreeSequenceField, } from "./core/index.js";
 import { TreeNodeValid } from "./treeNodeValid.js";
 import { getUnhydratedContext } from "./createContext.js";
@@ -157,6 +156,7 @@ export function asIndex(key, exclusiveMax) {
     return 0 <= asNumber && asNumber < exclusiveMax ? asNumber : undefined;
 }
 /**
+ * Create a proxy which implements the {@link TreeArrayNode} API.
  * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
  * Otherwise setting of unexpected properties will error.
  * @param proxyTarget - Target object of the proxy. Must provide an own `length` value property
@@ -431,6 +431,7 @@ CustomArrayNodeBase.kind = NodeKind.Array;
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function arraySchema(identifier, info, implicitlyConstructable, customizable, metadata) {
     const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(info));
+    const lazyAllowedTypesIdentifiers = new Lazy(() => new Set([...lazyChildTypes.value].map((type) => type.identifier)));
     let unhydratedContext;
     // 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.
@@ -452,6 +453,9 @@ export function arraySchema(identifier, info, implicitlyConstructable, customiza
         static buildRawNode(instance, input) {
             return UnhydratedFlexTreeNode.getOrCreate(unhydratedContext, mapTreeFromNodeData(input, this));
         }
+        static get allowedTypesIdentifiers() {
+            return lazyAllowedTypesIdentifiers.value;
+        }
         static oneTimeSetup() {
             const schema = this;
             unhydratedContext = getUnhydratedContext(schema);
@@ -499,7 +503,7 @@ export function arraySchema(identifier, info, implicitlyConstructable, customiza
     Schema.identifier = identifier;
     Schema.info = info;
     Schema.implicitlyConstructable = implicitlyConstructable;
-    Schema.metadata = metadata;
+    Schema.metadata = metadata ?? {};
     const output = Schema;
     return output;
 }