@fluidframework/tree 2.51.0 → 2.52.0

package/dist/feature-libraries/initializeForest.d.ts

@@ -1,18 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { IIdCompressor } from "@fluidframework/id-compressor";
-import { type IEditableForest, type ITreeCursorSynchronous, type RevisionTagCodec } from "../core/index.js";
-/**
- * Initializes the given forest with the given content.
- * @remarks The forest must be empty when this function is called.
- * This does not perform an edit in the typical sense.
- * Instead, it creates a delta expressing a creation and insertion of the `content` under the {@link rootFieldKey}, and then applies the delta to the forest.
- * If `visitAnchors` is enabled, then the delta will also be applied to the forest's {@link AnchorSet} (in which case there must be no existing anchors when this function is called).
- *
- * @remarks
- * This does not perform an edit: it updates the forest content as if there was an edit that did that.
- */
-export declare function initializeForest(forest: IEditableForest, content: ITreeCursorSynchronous, revisionTagCodec: RevisionTagCodec, idCompressor: IIdCompressor, visitAnchors?: boolean): void;
-//# sourceMappingURL=initializeForest.d.ts.map

package/dist/feature-libraries/initializeForest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initializeForest.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/initializeForest.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAA4B,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE7F,OAAO,EAEN,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EAKrB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,sBAAsB,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,YAAY,EAAE,aAAa,EAC3B,YAAY,UAAQ,GAClB,IAAI,CAmBN"}

package/dist/feature-libraries/initializeForest.js

@@ -1,35 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeForest = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../core/index.js");
-/**
- * Initializes the given forest with the given content.
- * @remarks The forest must be empty when this function is called.
- * This does not perform an edit in the typical sense.
- * Instead, it creates a delta expressing a creation and insertion of the `content` under the {@link rootFieldKey}, and then applies the delta to the forest.
- * If `visitAnchors` is enabled, then the delta will also be applied to the forest's {@link AnchorSet} (in which case there must be no existing anchors when this function is called).
- *
- * @remarks
- * This does not perform an edit: it updates the forest content as if there was an edit that did that.
- */
-function initializeForest(forest, content, revisionTagCodec, idCompressor, visitAnchors = false) {
-    (0, internal_1.assert)(forest.isEmpty, 0x747 /* forest must be empty */);
-    const delta = (0, index_js_1.deltaForRootInitialization)(forest.chunkField(content));
-    let visitor = forest.acquireVisitor();
-    if (visitAnchors) {
-        (0, internal_1.assert)(forest.anchors.isEmpty(), 0x9b7 /* anchor set must be empty */);
-        const anchorVisitor = forest.anchors.acquireVisitor();
-        visitor = (0, index_js_1.combineVisitors)([visitor, anchorVisitor]);
-    }
-    // any detached trees built here are immediately attached so the revision used here doesn't matter
-    // we use a dummy revision to make correctness checks in the detached field index easier
-    (0, index_js_1.visitDelta)(delta, visitor, (0, index_js_1.makeDetachedFieldIndex)("init", revisionTagCodec, idCompressor), 0);
-    visitor.free();
-}
-exports.initializeForest = initializeForest;
-//# sourceMappingURL=initializeForest.js.map

package/dist/feature-libraries/initializeForest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"initializeForest.js","sourceRoot":"","sources":["../../src/feature-libraries/initializeForest.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAG7D,+CAS0B;AAE1B;;;;;;;;;GASG;AACH,SAAgB,gBAAgB,CAC/B,MAAuB,EACvB,OAA+B,EAC/B,gBAAkC,EAClC,YAA2B,EAC3B,YAAY,GAAG,KAAK;IAEpB,IAAA,iBAAM,EAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;IACzD,MAAM,KAAK,GAAc,IAAA,qCAA0B,EAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAChF,IAAI,OAAO,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC;IACtC,IAAI,YAAY,EAAE,CAAC;QAClB,IAAA,iBAAM,EAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAC;QACvE,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QACtD,OAAO,GAAG,IAAA,0BAAe,EAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IACrD,CAAC;IAED,kGAAkG;IAClG,wFAAwF;IACxF,IAAA,qBAAU,EACT,KAAK,EACL,OAAO,EACP,IAAA,iCAAsB,EAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,CAAC,EAC9D,CAA6B,CAC7B,CAAC;IACF,OAAO,CAAC,IAAI,EAAE,CAAC;AAChB,CAAC;AAzBD,4CAyBC","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 type { SessionSpaceCompressedId, IIdCompressor } from \"@fluidframework/id-compressor\";\n\nimport {\n\ttype DeltaRoot,\n\ttype IEditableForest,\n\ttype ITreeCursorSynchronous,\n\ttype RevisionTagCodec,\n\tcombineVisitors,\n\tdeltaForRootInitialization,\n\tmakeDetachedFieldIndex,\n\tvisitDelta,\n} from \"../core/index.js\";\n\n/**\n * Initializes the given forest with the given content.\n * @remarks The forest must be empty when this function is called.\n * This does not perform an edit in the typical sense.\n * Instead, it creates a delta expressing a creation and insertion of the `content` under the {@link rootFieldKey}, and then applies the delta to the forest.\n * If `visitAnchors` is enabled, then the delta will also be applied to the forest's {@link AnchorSet} (in which case there must be no existing anchors when this function is called).\n *\n * @remarks\n * This does not perform an edit: it updates the forest content as if there was an edit that did that.\n */\nexport function initializeForest(\n\tforest: IEditableForest,\n\tcontent: ITreeCursorSynchronous,\n\trevisionTagCodec: RevisionTagCodec,\n\tidCompressor: IIdCompressor,\n\tvisitAnchors = false,\n): void {\n\tassert(forest.isEmpty, 0x747 /* forest must be empty */);\n\tconst delta: DeltaRoot = deltaForRootInitialization(forest.chunkField(content));\n\tlet visitor = forest.acquireVisitor();\n\tif (visitAnchors) {\n\t\tassert(forest.anchors.isEmpty(), 0x9b7 /* anchor set must be empty */);\n\t\tconst anchorVisitor = forest.anchors.acquireVisitor();\n\t\tvisitor = combineVisitors([visitor, anchorVisitor]);\n\t}\n\n\t// any detached trees built here are immediately attached so the revision used here doesn't matter\n\t// we use a dummy revision to make correctness checks in the detached field index easier\n\tvisitDelta(\n\t\tdelta,\n\t\tvisitor,\n\t\tmakeDetachedFieldIndex(\"init\", revisionTagCodec, idCompressor),\n\t\t0 as SessionSpaceCompressedId,\n\t);\n\tvisitor.free();\n}\n"]}

package/dist/simple-tree/discrepancies.d.ts

@@ -1,167 +0,0 @@
-/*!
- * 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 { type AnnotatedAllowedType, type TreeNodeSchema } from "./core/index.js";
-import { type FieldSchema } from "./fieldSchema.js";
-/**
- * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema.
- * @remarks
- *
- * 1. FieldDiscrepancy
- *
- * `FieldDiscrepancy` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
- * three types of incompatibilities:
- *
- * - FieldKindDiscrepancy: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
- * objects (e.g., optional, required, sequence, etc.).
- * - AllowedTypesDiscrepancy: Indicates the differences in the allowed child types between the two schemas.
- * - ValueSchemaDiscrepancy: Specifically indicates the differences in the `ValueSchema` of two
- * `LeafNodeStoredSchema` objects.
- *
- * 2. NodeDiscrepancy
- *
- * `NodeDiscrepancy` represents the differences between two `TreeNodeStoredSchema` objects and includes:
- *
- * - NodeKindDiscrepancy: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
- * `ObjectNodeStoredSchema`, `MapNodeStoredSchema`, and `LeafNodeStoredSchema`).
- * - NodeFieldsDiscrepancy: Indicates the `FieldDiscrepancy` of `TreeFieldStoredSchema` within two
- * `TreeNodeStoredSchema`. It includes an array of `FieldDiscrepancy` instances in the `differences` field.
- *
- * When comparing two nodes for compatibility, it only makes sense to compare their fields if the nodes are of
- * the same kind (map, object, leaf).
- *
- * 3. Discrepancy
- *
- * Discrepancy consists of both `NodeDiscrepancy` and `FieldDiscrepancy`, representing any kind of
- * schema differences. See {@link getAllowedContentDiscrepancies} for more details about how we process it
- * and the ordering.
- */
-export type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;
-export type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;
-/**
- * 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 in view/stored to enable more efficient checks for compatibility
- */
-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[];
-}
-export interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {
-    readonly mismatch: "fieldKind";
-    readonly view: FieldKindIdentifier;
-    readonly stored: FieldKindIdentifier;
-}
-export interface ValueSchemaDiscrepancy {
-    identifier: TreeNodeSchemaIdentifier;
-    mismatch: "valueSchema";
-    view: ValueSchema | undefined;
-    stored: ValueSchema | undefined;
-}
-export interface NodeKindDiscrepancy {
-    identifier: TreeNodeSchemaIdentifier;
-    mismatch: "nodeKind";
-    view: SchemaFactoryNodeKind | undefined;
-    stored: SchemaFactoryNodeKind | undefined;
-}
-export interface NodeFieldsDiscrepancy {
-    identifier: TreeNodeSchemaIdentifier;
-    mismatch: "fields";
-    differences: FieldDiscrepancy[];
-}
-type SchemaFactoryNodeKind = typeof ObjectNodeStoredSchema | typeof MapNodeStoredSchema | typeof LeafNodeStoredSchema;
-/**
- * Finds and reports discrepancies between a view schema and a stored schema.
- *
- * See documentation on {@link Discrepancy} for details of possible discrepancies.
- * @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.
- */
-export declare function getAllowedContentDiscrepancies(view: FieldSchema, 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): [readonly AnnotatedAllowedType<TreeNodeSchema>[], TreeNodeSchemaIdentifier[]];
-/**
- * A linear extension of a partially-ordered set of `T`s. See:
- * https://en.wikipedia.org/wiki/Linear_extension
- *
- * The linear extension is represented as a lookup from each poset element to its index in the linear extension.
- */
-export type LinearExtension<T> = Map<T, number>;
-/**
- * A realizer for a partially-ordered set. See:
- * https://en.wikipedia.org/wiki/Order_dimension
- */
-export type Realizer<T> = LinearExtension<T>[];
-/**
- * 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 declare const fieldRealizer: Realizer<FieldKindIdentifier>;
-export declare const PosetComparisonResult: {
-    readonly Less: "<";
-    readonly Greater: ">";
-    readonly Equal: "=";
-    readonly Incomparable: "||";
-};
-type PosetComparisonResult = (typeof PosetComparisonResult)[keyof typeof PosetComparisonResult];
-/**
- * TODO: This is used by SchemaCompatibilityTester, revisit it during redesign and document
- */
-export declare function comparePosetElements<T>(a: T, b: T, realizer: Realizer<T>): PosetComparisonResult;
-export {};
-//# sourceMappingURL=discrepancies.d.ts.map

package/dist/simple-tree/discrepancies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../src/simple-tree/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,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,kBAAkB,CAAC;AAE1B,OAAO,EAAY,KAAK,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAU3F,OAAO,EAIN,KAAK,WAAW,EAChB,MAAM,kBAAkB,CAAC;AAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAE1E;;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,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,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,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACxC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACrC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,KAAK,qBAAqB,GACvB,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,GAC1B,OAAO,oBAAoB,CAAC;AAmD/B;;;;;;;;;;GAUG;AACH,wBAAiB,8BAA8B,CAC9C,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CA4CvB;AAyHD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,gBAAgB,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,EACjE,kBAAkB,EAAE,WAAW,GAC7B,CAAC,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,EAAE,wBAAwB,EAAE,CAAC,CAW/E;AA2ID;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;AAgB/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,mBAAmB,CAegC,CAAC;AAEzF,eAAO,MAAM,qBAAqB;;;;;CAKxB,CAAC;AACX,KAAK,qBAAqB,GACzB,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACrC,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,EACJ,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACnB,qBAAqB,CAqBvB"}

package/dist/simple-tree/discrepancies.js

@@ -1,382 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.comparePosetElements = exports.PosetComparisonResult = exports.fieldRealizer = exports.findExtraAllowedTypes = exports.getAllowedContentDiscrepancies = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../core/index.js");
-const index_js_2 = require("../util/index.js");
-const index_js_3 = require("./core/index.js");
-const index_js_4 = require("./node-kinds/index.js");
-const toStoredSchema_js_1 = require("./toStoredSchema.js");
-const walkFieldSchema_js_1 = require("./walkFieldSchema.js");
-const fieldSchema_js_1 = require("./fieldSchema.js");
-const leafNodeSchema_js_1 = require("./leafNodeSchema.js");
-function getStoredNodeSchemaType(nodeSchema) {
-    if (nodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
-        return index_js_1.ObjectNodeStoredSchema;
-    }
-    if (nodeSchema instanceof index_js_1.MapNodeStoredSchema) {
-        return index_js_1.MapNodeStoredSchema;
-    }
-    if (nodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
-        return index_js_1.LeafNodeStoredSchema;
-    }
-    (0, internal_1.fail)(0xbe8 /* Invalid stored node schema type */);
-}
-function doesNodeKindMatchStoredNodeKind(viewKind, storedType) {
-    switch (viewKind) {
-        case index_js_3.NodeKind.Leaf:
-            return storedType === index_js_1.LeafNodeStoredSchema;
-        case index_js_3.NodeKind.Array:
-        case index_js_3.NodeKind.Object:
-            return storedType === index_js_1.ObjectNodeStoredSchema;
-        case index_js_3.NodeKind.Map:
-        case index_js_3.NodeKind.Record:
-            return storedType === index_js_1.MapNodeStoredSchema;
-        default:
-            (0, internal_1.unreachableCase)(viewKind);
-    }
-}
-function getViewNodeSchemaType(schema) {
-    switch (schema.kind) {
-        case index_js_3.NodeKind.Leaf: {
-            return index_js_1.LeafNodeStoredSchema;
-        }
-        case index_js_3.NodeKind.Map:
-        case index_js_3.NodeKind.Record: {
-            return index_js_1.MapNodeStoredSchema;
-        }
-        case index_js_3.NodeKind.Object:
-        case index_js_3.NodeKind.Array: {
-            return index_js_1.ObjectNodeStoredSchema;
-        }
-        default:
-            (0, internal_1.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.
- * @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.
- */
-function* getAllowedContentDiscrepancies(view, stored) {
-    // check root schema discrepancies
-    yield* getFieldDiscrepancies(view, stored.rootFieldSchema, undefined, undefined);
-    const viewNodeSchema = new Map();
-    (0, walkFieldSchema_js_1.walkFieldSchema)(view, {
-        node: (schema) => {
-            const identifier = (0, index_js_2.brand)(schema.identifier);
-            (0, internal_1.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);
-        }
-    }
-    for (const [identifier, storedSchema] of stored.nodeSchema) {
-        if (!viewNodeSchema.has(identifier)) {
-            const storedType = getStoredNodeSchemaType(storedSchema);
-            yield {
-                identifier,
-                mismatch: "nodeKind",
-                view: undefined,
-                stored: storedType,
-            };
-        }
-    }
-}
-exports.getAllowedContentDiscrepancies = getAllowedContentDiscrepancies;
-function* getNodeDiscrepancies(identifier, view, stored) {
-    if (!doesNodeKindMatchStoredNodeKind(view.kind, getStoredNodeSchemaType(stored))) {
-        yield {
-            identifier,
-            mismatch: "nodeKind",
-            view: getViewNodeSchemaType(view),
-            stored: getStoredNodeSchemaType(stored),
-        };
-        return;
-    }
-    switch (view.kind) {
-        case index_js_3.NodeKind.Object: {
-            (0, internal_1.assert)((0, index_js_4.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,
-                };
-            }
-            break;
-        }
-        case index_js_3.NodeKind.Array: {
-            (0, internal_1.assert)((0, index_js_4.isArrayNodeSchema)(view), 0xbea /* schema with node kind of array must implement ArrayNodeSchema */);
-            const fields = new Map([
-                [
-                    index_js_1.EmptyKey,
-                    {
-                        storedKey: index_js_1.EmptyKey,
-                        schema: (0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info),
-                    },
-                ],
-            ]);
-            const differences = Array.from(computeObjectNodeDiscrepancies(identifier, fields, stored, true));
-            if (differences.length > 0) {
-                yield {
-                    identifier,
-                    mismatch: "fields",
-                    differences,
-                };
-            }
-            break;
-        }
-        case index_js_3.NodeKind.Map: {
-            (0, internal_1.assert)((0, index_js_4.isMapNodeSchema)(view), 0xbeb /* schema with node kind of map must implement MapNodeSchema */);
-            yield* getFieldDiscrepancies((0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info), stored.mapFields, identifier, undefined);
-            break;
-        }
-        case index_js_3.NodeKind.Record: {
-            (0, internal_1.assert)((0, index_js_4.isRecordNodeSchema)(view), 0xbec /* schema with node kind of record must implement RecordNodeSchema */);
-            yield* getFieldDiscrepancies((0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info), stored.mapFields, identifier, undefined);
-            break;
-        }
-        case index_js_3.NodeKind.Leaf: {
-            (0, internal_1.assert)(view instanceof leafNodeSchema_js_1.LeafNodeSchema, 0xbed /* schema with node kind of leaf must implement LeafNodeSchema */);
-            // TODO: leafKind seems like a bad name
-            const viewValue = view.leafKind;
-            const storedValue = stored.leafValue;
-            if (viewValue !== storedValue) {
-                yield {
-                    identifier,
-                    mismatch: "valueSchema",
-                    view: viewValue,
-                    stored: storedValue,
-                };
-            }
-            break;
-        }
-        default:
-            break;
-    }
-}
-/**
- * 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.
- */
-function findExtraAllowedTypes(viewAllowedTypes, storedAllowedTypes) {
-    const viewNodeSchemaIdentifiers = new Set(viewAllowedTypes.map((value) => value.type.identifier));
-    const viewExtraneousAllowedTypes = [...viewAllowedTypes].filter((value) => !storedAllowedTypes.has((0, index_js_2.brand)(value.type.identifier)));
-    const storedExtraneousAllowedTypes = [...storedAllowedTypes].filter((value) => !viewNodeSchemaIdentifiers.has(value));
-    return [viewExtraneousAllowedTypes, storedExtraneousAllowedTypes];
-}
-exports.findExtraAllowedTypes = findExtraAllowedTypes;
-/**
- * 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.
- * 3. If the field kind in the view schema is not compatible with the stored schema.
- *
- * 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.
- */
-function* getFieldDiscrepancies(view, stored, identifier, fieldKey, 
-// TODO: This is a temporary workaround until the comparison logic is redesigned.
-viewKindIsSequence = false) {
-    (0, internal_1.assert)(view instanceof fieldSchema_js_1.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,
-        };
-    }
-    const viewKind = toStoredSchema_js_1.convertFieldKind.get(view.kind) ??
-        (0, internal_1.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)) {
-        yield {
-            identifier,
-            fieldKey,
-            mismatch: "fieldKind",
-            view: viewKind.identifier,
-            stored: stored.kind,
-        };
-    }
-}
-/**
- * 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.
- *
- * This function yields discrepancies in the following cases:
- *
- * 1. If the view schema has fields that are not present in the stored schema.
- * 2. If the stored schema has fields that are not present in the view schema.
- * 3. If the field kind or allowed types of a field in the view schema is not compatible with the stored schema.
- *
- * 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) {
-    /**
-     * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
-     * three types of differences:
-     * 1. Fields that exist in the view schema but not in the stored schema.
-     * 2. Fields that exist in both schemas but have different contents.
-     * 3. Fields that exist in the stored schema but not in the view schema.
-     *
-     * First, the view schema is iterated to track the first two types of differences.
-     * Then, the stored schema is iterated to find the third type.
-     */
-    const viewKeys = new Set();
-    for (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view) {
-        const storedSchema = stored.objectNodeFields.get(fieldKey);
-        viewKeys.add(fieldKey);
-        // If the view schema has a field that's not in the stored schema
-        if (storedSchema === undefined) {
-            const viewKind = toStoredSchema_js_1.convertFieldKind.get(fieldSchema.kind) ??
-                (0, internal_1.fail)(0xbf0 /* A conversion from a FieldKind to a FlexFieldKind should exist */);
-            yield {
-                identifier,
-                fieldKey,
-                mismatch: "fieldKind",
-                view: viewKind.identifier,
-                stored: index_js_1.storedEmptyFieldSchema.kind,
-            };
-        }
-        else {
-            yield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey, viewKindIsSequence);
-        }
-    }
-    for (const [fieldKey, schema] of stored.objectNodeFields) {
-        // If the stored schema has a field that's not in the view schema
-        if (!viewKeys.has(fieldKey)) {
-            if (schema.kind === index_js_1.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;
-            }
-            yield {
-                identifier,
-                fieldKey,
-                mismatch: "fieldKind",
-                view: index_js_1.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: (0, index_js_2.brand)("Forbidden"),
-    required: (0, index_js_2.brand)("Value"),
-    identifier: (0, index_js_2.brand)("Identifier"),
-    optional: (0, index_js_2.brand)("Optional"),
-    sequence: (0, index_js_2.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
- * ```
- */
-exports.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])));
-exports.PosetComparisonResult = {
-    Less: "<",
-    Greater: ">",
-    Equal: "=",
-    Incomparable: "||",
-};
-/**
- * TODO: This is used by SchemaCompatibilityTester, revisit it during redesign and document
- */
-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);
-        (0, internal_1.assert)(aIndex !== undefined && bIndex !== undefined, 0xbf1 /* Invalid realizer */);
-        if (aIndex < bIndex) {
-            hasLessThanResult = true;
-        }
-        else if (aIndex > bIndex) {
-            hasGreaterThanResult = true;
-        }
-    }
-    return hasLessThanResult
-        ? hasGreaterThanResult
-            ? exports.PosetComparisonResult.Incomparable
-            : exports.PosetComparisonResult.Less
-        : hasGreaterThanResult
-            ? exports.PosetComparisonResult.Greater
-            : exports.PosetComparisonResult.Equal;
-}
-exports.comparePosetElements = comparePosetElements;
-//# sourceMappingURL=discrepancies.js.map