@fluidframework/tree 2.51.0 → 2.52.0

package/lib/simple-tree/api/discrepancies.d.ts

@@ -0,0 +1,98 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type FieldKey, type FieldKindIdentifier, LeafNodeStoredSchema, MapNodeStoredSchema, ObjectNodeStoredSchema, type TreeNodeSchemaIdentifier, type TreeStoredSchema, type TreeTypeSet, type ValueSchema } from "../../core/index.js";
+import { NodeKind, type AnnotatedAllowedType, type TreeNodeSchema } from "../core/index.js";
+import type { TreeSchema } from "./configuration.js";
+/**
+ * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema which
+ * make it possible for content matching the stored schema to be incompatible with the view schema.
+ */
+export type Discrepancy = FieldDiscrepancy | NodeKindDiscrepancy;
+/**
+ * A discrepancy in the declaration of a field.
+ */
+export type FieldDiscrepancy = AllowedTypeDiscrepancy | FieldKindDiscrepancy | ValueSchemaDiscrepancy;
+/**
+ * Information about where a field discrepancy is located within a collection of schema.
+ */
+export interface FieldDiscrepancyLocation {
+    /**
+     * The {@link TreeNodeSchemaIdentifier} that contains the discrepancy.
+     *
+     * Undefined iff the discrepancy is part of the root field schema.
+     */
+    readonly identifier: TreeNodeSchemaIdentifier | undefined;
+    /**
+     * The {@link FieldKey} for the field that contains the discrepancy.
+     * Undefined when:
+     * - the discrepancy is part of the root field schema
+     * - the discrepancy is for 'all fields' of a map node
+     */
+    readonly fieldKey: FieldKey | undefined;
+}
+/**
+ * A discrepancy in the allowed types of a field.
+ *
+ * @remarks
+ * This reports the symmetric difference of allowed types.
+ */
+export interface AllowedTypeDiscrepancy extends FieldDiscrepancyLocation {
+    readonly mismatch: "allowedTypes";
+    /**
+     * List of annotated allowed types in viewed schema which are not allowed in stored schema
+     */
+    readonly view: readonly AnnotatedAllowedType<TreeNodeSchema>[];
+    /**
+     * List of allowed type identifiers in stored schema which are not allowed in view schema
+     */
+    readonly stored: readonly TreeNodeSchemaIdentifier[];
+}
+/**
+ * Differences in `FieldKindIdentifier` between two schema.
+ */
+export interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {
+    readonly mismatch: "fieldKind";
+    readonly view: FieldKindIdentifier;
+    readonly stored: FieldKindIdentifier;
+}
+/**
+ * Differences in the `ValueSchema` of two `LeafNodeStoredSchema` objects.
+ */
+export interface ValueSchemaDiscrepancy {
+    identifier: TreeNodeSchemaIdentifier;
+    mismatch: "valueSchema";
+    view: ValueSchema | undefined;
+    stored: ValueSchema | undefined;
+}
+/**
+ * Differences in the kind of node schema.
+ *
+ * Includes when stored object schema are expected to be compatible with an array node schema.
+ */
+export interface NodeKindDiscrepancy {
+    identifier: TreeNodeSchemaIdentifier;
+    mismatch: "nodeKind";
+    view: NodeKind;
+    stored: SchemaFactoryNodeKind;
+}
+type SchemaFactoryNodeKind = typeof ObjectNodeStoredSchema | typeof MapNodeStoredSchema | typeof LeafNodeStoredSchema;
+/**
+ * Finds and reports discrepancies between a view schema and a stored schema which make "canView" false.
+ * @remarks
+ * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.
+ */
+export declare function getDiscrepanciesInAllowedContent(view: TreeSchema, stored: TreeStoredSchema): Iterable<Discrepancy>;
+/**
+ * Returns the allowed types that are not present in both the given view and stored schemas.
+ * It returns a tuple containing two arrays:
+ * 1. The first array contains the allowed types that are present in the view schema but not in the stored schema.
+ * 2. The second array contains the allowed types that are present in the stored schema but not in the view schema.
+ */
+export declare function findExtraAllowedTypes(viewAllowedTypes: readonly AnnotatedAllowedType<TreeNodeSchema>[], storedAllowedTypes: TreeTypeSet): {
+    viewExtra: readonly AnnotatedAllowedType<TreeNodeSchema>[];
+    storedExtra: TreeNodeSchemaIdentifier[];
+};
+export {};
+//# sourceMappingURL=discrepancies.d.ts.map

package/lib/simple-tree/api/discrepancies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAExB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EAGtB,KAAK,wBAAwB,EAE7B,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,QAAQ,EAER,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,MAAM,kBAAkB,CAAC;AAgB1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIrD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC1D;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACvE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,CAAC;IAC/D;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB;IACrE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,qBAAqB,CAAC;CAC9B;AAED,KAAK,qBAAqB,GACvB,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,GAC1B,OAAO,oBAAoB,CAAC;AAiC/B;;;;GAIG;AACH,wBAAiB,gCAAgC,CAChD,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CAcvB;AA2GD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,gBAAgB,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,EACjE,kBAAkB,EAAE,WAAW,GAC7B;IACF,SAAS,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,CAAC;IAC3D,WAAW,EAAE,wBAAwB,EAAE,CAAC;CACxC,CAYA"}

package/lib/simple-tree/{discrepancies.js → api/discrepancies.js}

@@ -2,15 +2,16 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert, debugAssert, fail, unreachableCase, } from "@fluidframework/core-utils/internal";
-import { EmptyKey, forbiddenFieldKindIdentifier, LeafNodeStoredSchema, MapNodeStoredSchema, ObjectNodeStoredSchema, storedEmptyFieldSchema, } from "../core/index.js";
-import { brand } from "../util/index.js";
-import { NodeKind } from "./core/index.js";
-import { isArrayNodeSchema, isMapNodeSchema, isObjectNodeSchema, isRecordNodeSchema, } from "./node-kinds/index.js";
-import { convertFieldKind } from "./toStoredSchema.js";
-import { walkFieldSchema } from "./walkFieldSchema.js";
-import { createFieldSchema, FieldKind, FieldSchemaAlpha, } from "./fieldSchema.js";
-import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
+import { EmptyKey, forbiddenFieldKindIdentifier, LeafNodeStoredSchema, MapNodeStoredSchema, ObjectNodeStoredSchema, storedEmptyFieldSchema, } from "../../core/index.js";
+import { brand } from "../../util/index.js";
+import { NodeKind, normalizeAnnotatedAllowedTypes, } from "../core/index.js";
+import { isArrayNodeSchema, isMapNodeSchema, isObjectNodeSchema, isRecordNodeSchema, } from "../node-kinds/index.js";
+import { convertFieldKind } from "../toStoredSchema.js";
+import { createFieldSchema, FieldKind, FieldSchemaAlpha, } from "../fieldSchema.js";
+import { LeafNodeSchema } from "../leafNodeSchema.js";
+import { tryStoredSchemaAsArray } from "./customTree.js";
+import { FieldKinds } from "../../feature-libraries/index.js";
 function getStoredNodeSchemaType(nodeSchema) {
     if (nodeSchema instanceof ObjectNodeStoredSchema) {
         return ObjectNodeStoredSchema;
@@ -37,72 +38,22 @@ function doesNodeKindMatchStoredNodeKind(viewKind, storedType) {
             unreachableCase(viewKind);
     }
 }
-function getViewNodeSchemaType(schema) {
-    switch (schema.kind) {
-        case NodeKind.Leaf: {
-            return LeafNodeStoredSchema;
-        }
-        case NodeKind.Map:
-        case NodeKind.Record: {
-            return MapNodeStoredSchema;
-        }
-        case NodeKind.Object:
-        case NodeKind.Array: {
-            return ObjectNodeStoredSchema;
-        }
-        default:
-            unreachableCase(schema.kind);
-    }
-}
 /**
- * Finds and reports discrepancies between a view schema and a stored schema.
- *
- * See documentation on {@link Discrepancy} for details of possible discrepancies.
+ * Finds and reports discrepancies between a view schema and a stored schema which make "canView" false.
  * @remarks
- * This function does not attempt to distinguish between equivalent representations of a node/field involving extraneous never trees.
- * For example, a Forbidden field with allowed type set `[]` is equivalent to an optional field with allowed type set `[]`,
- * as well as an optional field with an allowed type set containing only unconstructable types.
- *
- * It is up to the caller to determine whether such discrepancies matter.
+ * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.
  */
-export function* getAllowedContentDiscrepancies(view, stored) {
-    // check root schema discrepancies
-    yield* getFieldDiscrepancies(view, stored.rootFieldSchema, undefined, undefined);
-    const viewNodeSchema = new Map();
-    walkFieldSchema(view, {
-        node: (schema) => {
-            const identifier = brand(schema.identifier);
-            debugAssert(() => !viewNodeSchema.has(identifier));
-            viewNodeSchema.set(identifier, schema);
-        },
-    });
-    for (const [identifier, viewSchema] of viewNodeSchema) {
-        const storedSchema = stored.nodeSchema.get(identifier);
-        // if the view schema has a node that's not in the stored schema
-        if (storedSchema === undefined) {
-            const viewType = getViewNodeSchemaType(viewSchema);
-            // TODO does it make sense to have this mismatch when there will also be an allowedTypes mismatch?
-            yield {
-                identifier,
-                mismatch: "nodeKind",
-                view: viewType,
-                stored: undefined,
-            };
-        }
-        else {
-            yield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);
-        }
-    }
+export function* getDiscrepanciesInAllowedContent(view, stored) {
+    // check root field discrepancies
+    yield* getFieldDiscrepancies(view.root, stored.rootFieldSchema, undefined, undefined);
+    // Check all of the stored nodes, including their fields for discrepancies.
     for (const [identifier, storedSchema] of stored.nodeSchema) {
-        if (!viewNodeSchema.has(identifier)) {
-            const storedType = getStoredNodeSchemaType(storedSchema);
-            yield {
-                identifier,
-                mismatch: "nodeKind",
-                view: undefined,
-                stored: storedType,
-            };
+        const viewSchema = view.definitions.get(identifier);
+        // if the view schema has a node that's also in the stored schema, check it.
+        if (viewSchema !== undefined) {
+            yield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);
         }
+        // Note that nodes that are missing in the view schema are only a problem if other stored schema nodes actually reference them which will produce its own discrepancy, so we can rely on that to produce any needed discrepancies.
     }
 }
 function* getNodeDiscrepancies(identifier, view, stored) {
@@ -110,7 +61,7 @@ function* getNodeDiscrepancies(identifier, view, stored) {
         yield {
             identifier,
             mismatch: "nodeKind",
-            view: getViewNodeSchemaType(view),
+            view: view.kind,
             stored: getStoredNodeSchemaType(stored),
         };
         return;
@@ -118,36 +69,22 @@ function* getNodeDiscrepancies(identifier, view, stored) {
     switch (view.kind) {
         case NodeKind.Object: {
             assert(isObjectNodeSchema(view), 0xbe9 /* schema with node kind of object must implement ObjectNodeSchema */);
-            const fields = view.flexKeyMap;
-            const differences = Array.from(computeObjectNodeDiscrepancies(identifier, fields, stored));
-            if (differences.length > 0) {
-                yield {
-                    identifier,
-                    mismatch: "fields",
-                    differences,
-                };
-            }
+            yield* computeObjectNodeDiscrepancies(identifier, view, stored);
             break;
         }
         case NodeKind.Array: {
             assert(isArrayNodeSchema(view), 0xbea /* schema with node kind of array must implement ArrayNodeSchema */);
-            const fields = new Map([
-                [
-                    EmptyKey,
-                    {
-                        storedKey: EmptyKey,
-                        schema: createFieldSchema(FieldKind.Optional, view.info),
-                    },
-                ],
-            ]);
-            const differences = Array.from(computeObjectNodeDiscrepancies(identifier, fields, stored, true));
-            if (differences.length > 0) {
+            const arrayStoredSchema = tryStoredSchemaAsArray(stored);
+            if (arrayStoredSchema === undefined) {
                 yield {
                     identifier,
-                    mismatch: "fields",
-                    differences,
+                    mismatch: "nodeKind",
+                    view: NodeKind.Array,
+                    stored: getStoredNodeSchemaType(stored),
                 };
+                return;
             }
+            yield* getAllowedTypeDiscrepancies(normalizeAnnotatedAllowedTypes(view.info).types, arrayStoredSchema, brand(view.identifier), EmptyKey);
             break;
         }
         case NodeKind.Map: {
@@ -187,9 +124,9 @@ function* getNodeDiscrepancies(identifier, view, stored) {
  */
 export function findExtraAllowedTypes(viewAllowedTypes, storedAllowedTypes) {
     const viewNodeSchemaIdentifiers = new Set(viewAllowedTypes.map((value) => value.type.identifier));
-    const viewExtraneousAllowedTypes = [...viewAllowedTypes].filter((value) => !storedAllowedTypes.has(brand(value.type.identifier)));
-    const storedExtraneousAllowedTypes = [...storedAllowedTypes].filter((value) => !viewNodeSchemaIdentifiers.has(value));
-    return [viewExtraneousAllowedTypes, storedExtraneousAllowedTypes];
+    const viewExtra = viewAllowedTypes.filter((value) => !storedAllowedTypes.has(brand(value.type.identifier)));
+    const storedExtra = [...storedAllowedTypes].filter((value) => !viewNodeSchemaIdentifiers.has(value));
+    return { viewExtra, storedExtra };
 }
 /**
  * The function to track the discrepancies between a field view schema and a stored schema.
@@ -202,28 +139,15 @@ export function findExtraAllowedTypes(viewAllowedTypes, storedAllowedTypes) {
  *
  * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.
  *
- * @param keyOrRoot - If the key is missing, it indicates that this is the root field schema.
+ * @param fieldKey - If the key is missing, it indicates that this is the root field schema.
  */
-function* getFieldDiscrepancies(view, stored, identifier, fieldKey, 
-// TODO: This is a temporary workaround until the comparison logic is redesigned.
-viewKindIsSequence = false) {
+function* getFieldDiscrepancies(view, stored, identifier, fieldKey) {
     assert(view instanceof FieldSchemaAlpha, 0xbee /* all field schema should be FieldSchemaAlpha */);
-    const [viewExtra, storedExtra] = findExtraAllowedTypes(view.annotatedAllowedTypesNormalized.types, stored.types);
-    if (viewExtra.length > 0 || storedExtra.length > 0) {
-        yield {
-            identifier,
-            fieldKey,
-            mismatch: "allowedTypes",
-            view: viewExtra,
-            stored: storedExtra,
-        };
-    }
+    yield* getAllowedTypeDiscrepancies(view.annotatedAllowedTypesNormalized.types, stored.types, identifier, fieldKey);
     const viewKind = convertFieldKind.get(view.kind) ??
         fail(0xbef /* A conversion from a FieldKind to a FlexFieldKind should exist */);
     // This checks if the field kind in the view schema is not compatible with the stored schema.
-    // We cannot detect if the view schema is a sequence using the kind property so it is passed in separately.
-    if ((viewKindIsSequence && stored.kind !== "Sequence") ||
-        (!viewKindIsSequence && viewKind.identifier !== stored.kind)) {
+    if (viewKind.identifier !== stored.kind) {
         yield {
             identifier,
             fieldKey,
@@ -233,6 +157,30 @@ viewKindIsSequence = false) {
         };
     }
 }
+/**
+ * The function to track the discrepancies between a field view schema and a stored schema.
+ *
+ * @remarks
+ * This function yields discrepancies in the following cases:
+ * 1. If the view schema has allowed types that are not present in the stored schema.
+ * 2. If the stored schema has allowed types that are not present in the view schema.
+ *
+ * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.
+ *
+ * @param fieldKey - If the key is missing, it indicates that this is the root field schema.
+ */
+function* getAllowedTypeDiscrepancies(view, stored, identifier, fieldKey) {
+    const { viewExtra, storedExtra } = findExtraAllowedTypes(view, stored);
+    if (viewExtra.length > 0 || storedExtra.length > 0) {
+        yield {
+            identifier,
+            fieldKey,
+            mismatch: "allowedTypes",
+            view: viewExtra,
+            stored: storedExtra,
+        };
+    }
+}
 /**
  * Computes discrepancies between a view schema and a stored schema for nodes that are treated as object nodes in the stored schema.
  * This includes both view object nodes and view array nodes.
@@ -245,7 +193,7 @@ viewKindIsSequence = false) {
  *
  * This function includes discrepancies within the common fields and their allowed types, but does NOT recurse to report and discrepancies within the node types referenced by those fields.
  */
-function* computeObjectNodeDiscrepancies(identifier, view, stored, viewKindIsSequence = false) {
+function* computeObjectNodeDiscrepancies(identifier, view, stored) {
     /**
      * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
      * three types of differences:
@@ -257,7 +205,7 @@ function* computeObjectNodeDiscrepancies(identifier, view, stored, viewKindIsSeq
      * Then, the stored schema is iterated to find the third type.
      */
     const viewKeys = new Set();
-    for (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view) {
+    for (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view.flexKeyMap) {
         const storedSchema = stored.objectNodeFields.get(fieldKey);
         viewKeys.add(fieldKey);
         // If the view schema has a field that's not in the stored schema
@@ -273,104 +221,30 @@ function* computeObjectNodeDiscrepancies(identifier, view, stored, viewKindIsSeq
             };
         }
         else {
-            yield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey, viewKindIsSequence);
+            yield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey);
         }
     }
     for (const [fieldKey, schema] of stored.objectNodeFields) {
+        if (schema.kind === forbiddenFieldKindIdentifier) {
+            // In the stored schema the field is explicitly forbidden.
+            // This has the same semantics of the field not being mentioned in the stored schema,
+            // and thus can be skipped.
+            continue;
+        }
         // If the stored schema has a field that's not in the view schema
         if (!viewKeys.has(fieldKey)) {
-            if (schema.kind === forbiddenFieldKindIdentifier) {
-                // In the stored schema the field is explicitly forbidden.
-                // This has the same semantics of the field not being mentioned in the stored schema,
-                // and thus is compatible with the view schema which does not mention this field.
-                continue;
+            // When the application has opted into it, we allow viewing documents which have additional
+            // optional fields in the stored schema that are not present in the view schema.
+            if (!view.allowUnknownOptionalFields || schema.kind !== FieldKinds.optional.identifier) {
+                yield {
+                    identifier,
+                    fieldKey,
+                    mismatch: "fieldKind",
+                    view: storedEmptyFieldSchema.kind,
+                    stored: schema.kind,
+                };
             }
-            yield {
-                identifier,
-                fieldKey,
-                mismatch: "fieldKind",
-                view: storedEmptyFieldSchema.kind,
-                stored: schema.kind,
-            };
-        }
-    }
-}
-/**
- * @privateRemarks
- * TODO: Knowledge of specific field kinds is not appropriate for modular schema.
- * This bit of field comparison should be dependency injected by default-schema if this comparison logic remains in modular-schema
- * (this is analogous to what is done in comparison.ts).
- */
-const FieldKindIdentifiers = {
-    forbidden: brand("Forbidden"),
-    required: brand("Value"),
-    identifier: brand("Identifier"),
-    optional: brand("Optional"),
-    sequence: brand("Sequence"),
-};
-/**
- * A realizer for the partial order of field kind relaxability.
- *
- * It seems extremely likely that this partial order will remain dimension 2 over time (i.e. the set of allowed relaxations can be visualized
- * with a [dominance drawing](https://en.wikipedia.org/wiki/Dominance_drawing)), so this strategy allows efficient comarison between field kinds
- * without excessive casework.
- *
- * Hasse diagram for the partial order is shown below (lower fields can be relaxed to higher fields):
- * ```
- * sequence
- *    |
- * optional
- *    |    \
- * required forbidden
- *    |
- * identifier
- * ```
- */
-export const fieldRealizer = [
-    [
-        FieldKindIdentifiers.forbidden,
-        FieldKindIdentifiers.identifier,
-        FieldKindIdentifiers.required,
-        FieldKindIdentifiers.optional,
-        FieldKindIdentifiers.sequence,
-    ],
-    [
-        FieldKindIdentifiers.identifier,
-        FieldKindIdentifiers.required,
-        FieldKindIdentifiers.forbidden,
-        FieldKindIdentifiers.optional,
-        FieldKindIdentifiers.sequence,
-    ],
-].map((extension) => new Map(extension.map((identifier, index) => [identifier, index])));
-export const PosetComparisonResult = {
-    Less: "<",
-    Greater: ">",
-    Equal: "=",
-    Incomparable: "||",
-};
-/**
- * TODO: This is used by SchemaCompatibilityTester, revisit it during redesign and document
- */
-export function comparePosetElements(a, b, realizer) {
-    let hasLessThanResult = false;
-    let hasGreaterThanResult = false;
-    for (const extension of realizer) {
-        const aIndex = extension.get(a);
-        const bIndex = extension.get(b);
-        assert(aIndex !== undefined && bIndex !== undefined, 0xbf1 /* Invalid realizer */);
-        if (aIndex < bIndex) {
-            hasLessThanResult = true;
-        }
-        else if (aIndex > bIndex) {
-            hasGreaterThanResult = true;
         }
     }
-    return hasLessThanResult
-        ? hasGreaterThanResult
-            ? PosetComparisonResult.Incomparable
-            : PosetComparisonResult.Less
-        : hasGreaterThanResult
-            ? PosetComparisonResult.Greater
-            : PosetComparisonResult.Equal;
 }
 //# sourceMappingURL=discrepancies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discrepancies.js","sourceRoot":"","sources":["../../../src/simple-tree/api/discrepancies.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\";\n\nimport {\n\tEmptyKey,\n\ttype FieldKey,\n\ttype FieldKindIdentifier,\n\tforbiddenFieldKindIdentifier,\n\tLeafNodeStoredSchema,\n\tMapNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\tstoredEmptyFieldSchema,\n\ttype TreeFieldStoredSchema,\n\ttype TreeNodeSchemaIdentifier,\n\ttype TreeNodeStoredSchema,\n\ttype TreeStoredSchema,\n\ttype TreeTypeSet,\n\ttype ValueSchema,\n} from \"../../core/index.js\";\nimport { brand } from \"../../util/index.js\";\nimport {\n\tNodeKind,\n\tnormalizeAnnotatedAllowedTypes,\n\ttype AnnotatedAllowedType,\n\ttype TreeNodeSchema,\n} from \"../core/index.js\";\nimport {\n\tisArrayNodeSchema,\n\tisMapNodeSchema,\n\tisObjectNodeSchema,\n\tisRecordNodeSchema,\n\ttype ObjectNodeSchemaPrivate,\n} from \"../node-kinds/index.js\";\nimport { convertFieldKind } from \"../toStoredSchema.js\";\nimport {\n\tcreateFieldSchema,\n\tFieldKind,\n\tFieldSchemaAlpha,\n\ttype FieldSchema,\n} from \"../fieldSchema.js\";\nimport { LeafNodeSchema } from \"../leafNodeSchema.js\";\nimport type { TreeSchema } from \"./configuration.js\";\nimport { tryStoredSchemaAsArray } from \"./customTree.js\";\nimport { FieldKinds } from \"../../feature-libraries/index.js\";\n\n/**\n * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema which\n * make it possible for content matching the stored schema to be incompatible with the view schema.\n */\nexport type Discrepancy = FieldDiscrepancy | NodeKindDiscrepancy;\n\n/**\n * A discrepancy in the declaration of a field.\n */\nexport type FieldDiscrepancy =\n\t| AllowedTypeDiscrepancy\n\t| FieldKindDiscrepancy\n\t| ValueSchemaDiscrepancy;\n\n/**\n * Information about where a field discrepancy is located within a collection of schema.\n */\nexport interface FieldDiscrepancyLocation {\n\t/**\n\t * The {@link TreeNodeSchemaIdentifier} that contains the discrepancy.\n\t *\n\t * Undefined iff the discrepancy is part of the root field schema.\n\t */\n\treadonly identifier: TreeNodeSchemaIdentifier | undefined;\n\t/**\n\t * The {@link FieldKey} for the field that contains the discrepancy.\n\t * Undefined when:\n\t * - the discrepancy is part of the root field schema\n\t * - the discrepancy is for 'all fields' of a map node\n\t */\n\treadonly fieldKey: FieldKey | undefined;\n}\n\n/**\n * A discrepancy in the allowed types of a field.\n *\n * @remarks\n * This reports the symmetric difference of allowed types.\n */\nexport interface AllowedTypeDiscrepancy extends FieldDiscrepancyLocation {\n\treadonly mismatch: \"allowedTypes\";\n\t/**\n\t * List of annotated allowed types in viewed schema which are not allowed in stored schema\n\t */\n\treadonly view: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n\t/**\n\t * List of allowed type identifiers in stored schema which are not allowed in view schema\n\t */\n\treadonly stored: readonly TreeNodeSchemaIdentifier[];\n}\n\n/**\n * Differences in `FieldKindIdentifier` between two schema.\n */\nexport interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {\n\treadonly mismatch: \"fieldKind\";\n\treadonly view: FieldKindIdentifier;\n\treadonly stored: FieldKindIdentifier;\n}\n\n/**\n * Differences in the `ValueSchema` of two `LeafNodeStoredSchema` objects.\n */\nexport interface ValueSchemaDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"valueSchema\";\n\tview: ValueSchema | undefined;\n\tstored: ValueSchema | undefined;\n}\n\n/**\n * Differences in the kind of node schema.\n *\n * Includes when stored object schema are expected to be compatible with an array node schema.\n */\nexport interface NodeKindDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"nodeKind\";\n\tview: NodeKind;\n\tstored: SchemaFactoryNodeKind;\n}\n\ntype SchemaFactoryNodeKind =\n\t| typeof ObjectNodeStoredSchema\n\t| typeof MapNodeStoredSchema\n\t| typeof LeafNodeStoredSchema;\n\nfunction getStoredNodeSchemaType(nodeSchema: TreeNodeStoredSchema): SchemaFactoryNodeKind {\n\tif (nodeSchema instanceof ObjectNodeStoredSchema) {\n\t\treturn ObjectNodeStoredSchema;\n\t}\n\tif (nodeSchema instanceof MapNodeStoredSchema) {\n\t\treturn MapNodeStoredSchema;\n\t}\n\tif (nodeSchema instanceof LeafNodeStoredSchema) {\n\t\treturn LeafNodeStoredSchema;\n\t}\n\tfail(0xbe8 /* Invalid stored node schema type */);\n}\n\nfunction doesNodeKindMatchStoredNodeKind(\n\tviewKind: NodeKind,\n\tstoredType: SchemaFactoryNodeKind,\n): boolean {\n\tswitch (viewKind) {\n\t\tcase NodeKind.Leaf:\n\t\t\treturn storedType === LeafNodeStoredSchema;\n\t\tcase NodeKind.Array:\n\t\tcase NodeKind.Object:\n\t\t\treturn storedType === ObjectNodeStoredSchema;\n\t\tcase NodeKind.Map:\n\t\tcase NodeKind.Record:\n\t\t\treturn storedType === MapNodeStoredSchema;\n\t\tdefault:\n\t\t\tunreachableCase(viewKind);\n\t}\n}\n\n/**\n * Finds and reports discrepancies between a view schema and a stored schema which make \"canView\" false.\n * @remarks\n * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.\n */\nexport function* getDiscrepanciesInAllowedContent(\n\tview: TreeSchema,\n\tstored: TreeStoredSchema,\n): Iterable<Discrepancy> {\n\t// check root field discrepancies\n\tyield* getFieldDiscrepancies(view.root, stored.rootFieldSchema, undefined, undefined);\n\n\t// Check all of the stored nodes, including their fields for discrepancies.\n\tfor (const [identifier, storedSchema] of stored.nodeSchema) {\n\t\tconst viewSchema = view.definitions.get(identifier);\n\n\t\t// if the view schema has a node that's also in the stored schema, check it.\n\t\tif (viewSchema !== undefined) {\n\t\t\tyield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);\n\t\t}\n\t\t// Note that nodes that are missing in the view schema are only a problem if other stored schema nodes actually reference them which will produce its own discrepancy, so we can rely on that to produce any needed discrepancies.\n\t}\n}\n\nfunction* getNodeDiscrepancies(\n\tidentifier: TreeNodeSchemaIdentifier,\n\tview: TreeNodeSchema,\n\tstored: TreeNodeStoredSchema,\n): Iterable<Discrepancy> {\n\tif (!doesNodeKindMatchStoredNodeKind(view.kind, getStoredNodeSchemaType(stored))) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tmismatch: \"nodeKind\",\n\t\t\tview: view.kind,\n\t\t\tstored: getStoredNodeSchemaType(stored),\n\t\t};\n\t\treturn;\n\t}\n\n\tswitch (view.kind) {\n\t\tcase NodeKind.Object: {\n\t\t\tassert(\n\t\t\t\tisObjectNodeSchema(view),\n\t\t\t\t0xbe9 /* schema with node kind of object must implement ObjectNodeSchema */,\n\t\t\t);\n\t\t\tyield* computeObjectNodeDiscrepancies(\n\t\t\t\tidentifier,\n\t\t\t\tview,\n\t\t\t\tstored as ObjectNodeStoredSchema,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Array: {\n\t\t\tassert(\n\t\t\t\tisArrayNodeSchema(view),\n\t\t\t\t0xbea /* schema with node kind of array must implement ArrayNodeSchema */,\n\t\t\t);\n\n\t\t\tconst arrayStoredSchema = tryStoredSchemaAsArray(stored);\n\t\t\tif (arrayStoredSchema === undefined) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"nodeKind\",\n\t\t\t\t\tview: NodeKind.Array,\n\t\t\t\t\tstored: getStoredNodeSchemaType(stored),\n\t\t\t\t};\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tyield* getAllowedTypeDiscrepancies(\n\t\t\t\tnormalizeAnnotatedAllowedTypes(view.info).types,\n\t\t\t\tarrayStoredSchema,\n\t\t\t\tbrand(view.identifier),\n\t\t\t\tEmptyKey,\n\t\t\t);\n\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Map: {\n\t\t\tassert(\n\t\t\t\tisMapNodeSchema(view),\n\t\t\t\t0xbeb /* schema with node kind of map must implement MapNodeSchema */,\n\t\t\t);\n\n\t\t\tyield* getFieldDiscrepancies(\n\t\t\t\tcreateFieldSchema(FieldKind.Optional, view.info),\n\t\t\t\t(stored as MapNodeStoredSchema).mapFields,\n\t\t\t\tidentifier,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Record: {\n\t\t\tassert(\n\t\t\t\tisRecordNodeSchema(view),\n\t\t\t\t0xbec /* schema with node kind of record must implement RecordNodeSchema */,\n\t\t\t);\n\n\t\t\tyield* getFieldDiscrepancies(\n\t\t\t\tcreateFieldSchema(FieldKind.Optional, view.info),\n\t\t\t\t(stored as MapNodeStoredSchema).mapFields,\n\t\t\t\tidentifier,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Leaf: {\n\t\t\tassert(\n\t\t\t\tview instanceof LeafNodeSchema,\n\t\t\t\t0xbed /* schema with node kind of leaf must implement LeafNodeSchema */,\n\t\t\t);\n\t\t\t// TODO: leafKind seems like a bad name\n\t\t\tconst viewValue = view.leafKind;\n\t\t\tconst storedValue = (stored as LeafNodeStoredSchema).leafValue;\n\t\t\tif (viewValue !== storedValue) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"valueSchema\",\n\t\t\t\t\tview: viewValue,\n\t\t\t\t\tstored: storedValue,\n\t\t\t\t};\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tbreak;\n\t}\n}\n\n/**\n * Returns the allowed types that are not present in both the given view and stored schemas.\n * It returns a tuple containing two arrays:\n * 1. The first array contains the allowed types that are present in the view schema but not in the stored schema.\n * 2. The second array contains the allowed types that are present in the stored schema but not in the view schema.\n */\nexport function findExtraAllowedTypes(\n\tviewAllowedTypes: readonly AnnotatedAllowedType<TreeNodeSchema>[],\n\tstoredAllowedTypes: TreeTypeSet,\n): {\n\tviewExtra: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n\tstoredExtra: TreeNodeSchemaIdentifier[];\n} {\n\tconst viewNodeSchemaIdentifiers = new Set(\n\t\tviewAllowedTypes.map((value) => value.type.identifier),\n\t);\n\n\tconst viewExtra = viewAllowedTypes.filter(\n\t\t(value) => !storedAllowedTypes.has(brand(value.type.identifier)),\n\t);\n\tconst storedExtra = [...storedAllowedTypes].filter(\n\t\t(value) => !viewNodeSchemaIdentifiers.has(value),\n\t);\n\treturn { viewExtra, storedExtra };\n}\n\n/**\n * The function to track the discrepancies between a field view schema and a stored schema.\n *\n * @remarks\n * This function yields discrepancies in the following cases:\n * 1. If the view schema has allowed types that are not present in the stored schema.\n * 2. If the stored schema has allowed types that are not present in the view schema.\n * 3. If the field kind in the view schema is not compatible with the stored schema.\n *\n * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.\n *\n * @param fieldKey - If the key is missing, it indicates that this is the root field schema.\n */\nfunction* getFieldDiscrepancies(\n\tview: FieldSchema,\n\tstored: TreeFieldStoredSchema,\n\tidentifier: TreeNodeSchemaIdentifier | undefined,\n\tfieldKey: FieldKey | undefined,\n): Iterable<FieldDiscrepancy> {\n\tassert(\n\t\tview instanceof FieldSchemaAlpha,\n\t\t0xbee /* all field schema should be FieldSchemaAlpha */,\n\t);\n\tyield* getAllowedTypeDiscrepancies(\n\t\tview.annotatedAllowedTypesNormalized.types,\n\t\tstored.types,\n\t\tidentifier,\n\t\tfieldKey,\n\t);\n\n\tconst viewKind =\n\t\tconvertFieldKind.get(view.kind) ??\n\t\tfail(0xbef /* A conversion from a FieldKind to a FlexFieldKind should exist */);\n\n\t// This checks if the field kind in the view schema is not compatible with the stored schema.\n\tif (viewKind.identifier !== stored.kind) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tfieldKey,\n\t\t\tmismatch: \"fieldKind\",\n\t\t\tview: viewKind.identifier,\n\t\t\tstored: stored.kind,\n\t\t} satisfies FieldKindDiscrepancy;\n\t}\n}\n\n/**\n * The function to track the discrepancies between a field view schema and a stored schema.\n *\n * @remarks\n * This function yields discrepancies in the following cases:\n * 1. If the view schema has allowed types that are not present in the stored schema.\n * 2. If the stored schema has allowed types that are not present in the view schema.\n *\n * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.\n *\n * @param fieldKey - If the key is missing, it indicates that this is the root field schema.\n */\nfunction* getAllowedTypeDiscrepancies(\n\tview: readonly AnnotatedAllowedType<TreeNodeSchema>[],\n\tstored: TreeTypeSet,\n\tidentifier: TreeNodeSchemaIdentifier | undefined,\n\tfieldKey: FieldKey | undefined,\n): Iterable<FieldDiscrepancy> {\n\tconst { viewExtra, storedExtra } = findExtraAllowedTypes(view, stored);\n\tif (viewExtra.length > 0 || storedExtra.length > 0) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tfieldKey,\n\t\t\tmismatch: \"allowedTypes\",\n\t\t\tview: viewExtra,\n\t\t\tstored: storedExtra,\n\t\t} satisfies AllowedTypeDiscrepancy;\n\t}\n}\n\n/**\n * Computes discrepancies between a view schema and a stored schema for nodes that are treated as object nodes in the stored schema.\n * This includes both view object nodes and view array nodes.\n *\n * This function yields discrepancies in the following cases:\n *\n * 1. If the view schema has fields that are not present in the stored schema.\n * 2. If the stored schema has fields that are not present in the view schema.\n * 3. If the field kind or allowed types of a field in the view schema is not compatible with the stored schema.\n *\n * This function includes discrepancies within the common fields and their allowed types, but does NOT recurse to report and discrepancies within the node types referenced by those fields.\n */\nfunction* computeObjectNodeDiscrepancies(\n\tidentifier: TreeNodeSchemaIdentifier,\n\tview: ObjectNodeSchemaPrivate,\n\tstored: ObjectNodeStoredSchema,\n): Iterable<FieldDiscrepancy> {\n\t/**\n\t * Similar to the logic used for tracking discrepancies between two node schemas, we will identify\n\t * three types of differences:\n\t * 1. Fields that exist in the view schema but not in the stored schema.\n\t * 2. Fields that exist in both schemas but have different contents.\n\t * 3. Fields that exist in the stored schema but not in the view schema.\n\t *\n\t * First, the view schema is iterated to track the first two types of differences.\n\t * Then, the stored schema is iterated to find the third type.\n\t */\n\n\tconst viewKeys = new Set<FieldKey>();\n\n\tfor (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view.flexKeyMap) {\n\t\tconst storedSchema = stored.objectNodeFields.get(fieldKey);\n\t\tviewKeys.add(fieldKey);\n\n\t\t// If the view schema has a field that's not in the stored schema\n\t\tif (storedSchema === undefined) {\n\t\t\tconst viewKind =\n\t\t\t\tconvertFieldKind.get(fieldSchema.kind) ??\n\t\t\t\tfail(0xbf0 /* A conversion from a FieldKind to a FlexFieldKind should exist */);\n\t\t\tyield {\n\t\t\t\tidentifier,\n\t\t\t\tfieldKey,\n\t\t\t\tmismatch: \"fieldKind\",\n\t\t\t\tview: viewKind.identifier,\n\t\t\t\tstored: storedEmptyFieldSchema.kind,\n\t\t\t} satisfies FieldKindDiscrepancy;\n\t\t} else {\n\t\t\tyield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey);\n\t\t}\n\t}\n\n\tfor (const [fieldKey, schema] of stored.objectNodeFields) {\n\t\tif (schema.kind === forbiddenFieldKindIdentifier) {\n\t\t\t// In the stored schema the field is explicitly forbidden.\n\t\t\t// This has the same semantics of the field not being mentioned in the stored schema,\n\t\t\t// and thus can be skipped.\n\t\t\tcontinue;\n\t\t}\n\n\t\t// If the stored schema has a field that's not in the view schema\n\t\tif (!viewKeys.has(fieldKey)) {\n\t\t\t// When the application has opted into it, we allow viewing documents which have additional\n\t\t\t// optional fields in the stored schema that are not present in the view schema.\n\t\t\tif (!view.allowUnknownOptionalFields || schema.kind !== FieldKinds.optional.identifier) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tfieldKey,\n\t\t\t\t\tmismatch: \"fieldKind\",\n\t\t\t\t\tview: storedEmptyFieldSchema.kind,\n\t\t\t\t\tstored: schema.kind,\n\t\t\t\t} satisfies FieldKindDiscrepancy;\n\t\t\t}\n\t\t}\n\t}\n}\n"]}

package/lib/simple-tree/api/schemaCompatibilityTester.d.ts

@@ -3,21 +3,23 @@
  * Licensed under the MIT License.
  */
 import type { TreeStoredSchema } from "../../core/index.js";
-import { type FullSchemaPolicy } from "../../feature-libraries/index.js";
-import type { FieldSchema } from "../fieldSchema.js";
 import type { SchemaCompatibilityStatus } from "./tree.js";
+import type { TreeSchema } from "./configuration.js";
 /**
- * A collection of View information for schema, including policy.
+ * A collection of View information for schema
  * @remarks
  * This contains everything needed to determine compatibility with a given stored schema.
  */
 export declare class SchemaCompatibilityTester {
-    readonly policy: FullSchemaPolicy;
-    readonly viewSchemaRoot: FieldSchema;
     /**
-     * @param viewSchemaRoot - Schema for the root field.
+     * Schema for the view
      */
-    constructor(policy: FullSchemaPolicy, viewSchemaRoot: FieldSchema);
+    readonly viewSchema: TreeSchema;
+    constructor(
+    /**
+     * Schema for the view
+     */
+    viewSchema: TreeSchema);
     /**
      * Determines the compatibility of a stored document
      * (based on its stored schema) with a viewer (based on its view schema).

package/lib/simple-tree/api/schemaCompatibilityTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaCompatibilityTester.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaCompatibilityTester.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAGN,KAAK,gBAAgB,EAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAU3D;;;;GAIG;AACH,qBAAa,yBAAyB;aAKpB,MAAM,EAAE,gBAAgB;aACxB,cAAc,EAAE,WAAW;IAL5C;;OAEG;gBAEc,MAAM,EAAE,gBAAgB,EACxB,cAAc,EAAE,WAAW;IAG5C;;;;;;;;;OASG;IACI,kBAAkB,CACxB,MAAM,EAAE,gBAAgB,GACtB,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAC;CAgJnD"}
+{"version":3,"file":"schemaCompatibilityTester.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaCompatibilityTester.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAG3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,yBAAyB;IAEpC;;OAEG;aACa,UAAU,EAAE,UAAU;;IAHtC;;OAEG;IACa,UAAU,EAAE,UAAU;IAGvC;;;;;;;;;OASG;IACI,kBAAkB,CACxB,MAAM,EAAE,gBAAgB,GACtB,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAC;CAkCnD"}