@fluidframework/tree 2.10.0-307060 → 2.10.0

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @fluidframework/tree
 
+## 2.10.0
+
+### Minor Changes
+
+-   Fix typing bug in `adaptEnum` and `enumFromStrings` ([#23077](https://github.com/microsoft/FluidFramework/pull/23077)) [cfb68388cb](https://github.com/microsoft/FluidFramework/commit/cfb68388cb6b88a0ef670633b3afa46a82c99972)
+
+    When using the return value from [`adaptEnum`](https://fluidframework.com/docs/api/v2/tree#adaptenum-function) as a function, passing in a value who's type is a union no longer produced an incorrectly typed return value. This has been fixed.
+
+    Additionally [`enumFromStrings`](https://fluidframework.com/docs/api/v2/tree#enumfromstrings-function) has improved the typing of its schema, ensuring the returned object's members have sufficiently specific types.
+    Part of this improvement was fixing the `.schema` property to be a tuple over each of the schema where it was previously a tuple of a single combined schema due to a bug.
+
+    One side-effect of these fixes is that narrowing of the `value` field of a node typed from the `.schema` behaves slightly different, such that the node type is now a union instead of it being a single type with a `.value` that is a union.
+    This means that narrowing based on `.value` property narrows which node type you have, not just the value property.
+    This mainly matters when matching all cases like the switch statement below:
+
+    ```typescript
+    const Mode = enumFromStrings(schema, ["Fun", "Bonus"]);
+    type Mode = TreeNodeFromImplicitAllowedTypes<typeof Mode.schema>;
+    const node = new Mode.Bonus() as Mode;
+
+    switch (node.value) {
+    	case "Fun": {
+    		assert.fail();
+    	}
+    	case "Bonus": {
+    		// This one runs
+    		break;
+    	}
+    	default:
+    		// Before this change, "node.value" was never here, now "node" is never.
+    		unreachableCase(node);
+    }
+    ```
+
+-   SharedTree event listeners that implement `Listenable` now allow deregistration of event listeners via an `off()` function. ([#23046](https://github.com/microsoft/FluidFramework/pull/23046)) [c59225db03](https://github.com/microsoft/FluidFramework/commit/c59225db033a516ee20e459ae31567d97ce8776c)
+
+    The ability to deregister events via a callback returned by `on()` remains the same.
+    Both strategies will remain supported and consumers of SharedTree events may choose which method of deregistration they prefer in a given instance.
+
+    ```typescript
+    // The new behavior
+    function deregisterViaOff(view: TreeView<MySchema>): {
+    	const listener = () => { /* ... */ };
+    	view.events.on("commitApplied", listener); // Register
+    	view.events.off("commitApplied", listener); // Deregister
+    }
+
+    // The existing behavior (still supported)
+    function deregisterViaCallback(view: TreeView<MySchema>): {
+    	const off = view.events.on("commitApplied", () => { /* ... */ }); // Register
+    	off(); // Deregister
+    }
+    ```
+
+-   Allow constructing recursive maps from objects ([#23070](https://github.com/microsoft/FluidFramework/pull/23070)) [0185a08c6f](https://github.com/microsoft/FluidFramework/commit/0185a08c6f8bf6e922a6467f11da049503c4d215)
+
+    Previously only non-recursive maps could be constructed from objects.
+    Now all maps nodes can constructed from objects:
+
+    ```typescript
+    class MapRecursive extends sf.mapRecursive("Map", [() => MapRecursive]) {}
+    {
+    	type _check = ValidateRecursiveSchema<typeof MapRecursive>;
+    }
+    // New:
+    const fromObject = new MapRecursive({ x: new MapRecursive() });
+    // Existing:
+    const fromIterator = new MapRecursive([["x", new MapRecursive()]]);
+    const fromMap = new MapRecursive(new Map([["x", new MapRecursive()]]));
+    const fromNothing = new MapRecursive();
+    const fromUndefined = new MapRecursive(undefined);
+    ```
+
+-   Provide more comprehensive replacement to the `commitApplied` event ([#22977](https://github.com/microsoft/FluidFramework/pull/22977)) [e51c94da32](https://github.com/microsoft/FluidFramework/commit/e51c94da3248868de3c0c7fdce568cc425204155)
+
+    Adds a new `changed` event to the (currently alpha) `TreeBranchEvents` that replaces the `commitApplied` event on `TreeViewEvents`.
+    This new event is fired for both local and remote changes and maintains the existing functionality of `commitApplied` that is used for obtaining `Revertibles`.
+
 ## 2.5.0
 
 ### Minor Changes

package/dist/feature-libraries/modular-schema/discrepancies.d.ts

@@ -91,7 +91,7 @@ type SchemaFactoryNodeKind = "object" | "leaf" | "map";
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-export declare function getAllowedContentDiscrepancies(view: TreeStoredSchema, stored: TreeStoredSchema): Discrepancy[];
+export declare function getAllowedContentDiscrepancies(view: TreeStoredSchema, stored: TreeStoredSchema): Iterable<Discrepancy>;
 /**
  * @remarks
  *

package/dist/feature-libraries/modular-schema/discrepancies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,mBAAmB,EAOxB,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACpC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,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,MAAM,CAAC;IACnB,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,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,KAAK,qBAAqB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,8BAA8B,CAC7C,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACtB,WAAW,EAAE,CA4Jf;AAwGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAkCxF"}
+{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,KAAK,mBAAmB,EAQxB,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACpC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,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,MAAM,CAAC;IACnB,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,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,KAAK,qBAAqB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAavD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAiB,8BAA8B,CAC9C,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CAkCvB;AAkLD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAkCxF"}

package/dist/feature-libraries/modular-schema/discrepancies.js

@@ -8,6 +8,18 @@ exports.isRepoSuperset = 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");
+function getNodeSchemaType(nodeSchema) {
+    if (nodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
+        return "object";
+    }
+    else if (nodeSchema instanceof index_js_1.MapNodeStoredSchema) {
+        return "map";
+    }
+    else if (nodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
+        return "leaf";
+    }
+    throwUnsupportedNodeType(nodeSchema.constructor.name);
+}
 /**
  * Finds and reports discrepancies between a view schema and a stored schema.
  *
@@ -25,193 +37,116 @@ const index_js_2 = require("../../util/index.js");
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-function getAllowedContentDiscrepancies(view, stored) {
-    const discrepancies = [];
+function* getAllowedContentDiscrepancies(view, stored) {
     // check root schema discrepancies
-    discrepancies.push(...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema));
-    // Verify the existence and type of a node schema given its identifier (key), then determine if
-    // an exhaustive search is necessary.
-    const viewNodeKeys = new Set();
-    for (const [key, viewNodeSchema] of view.nodeSchema) {
-        viewNodeKeys.add(key);
-        if (viewNodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                discrepancies.push({
-                    identifier: key,
+    yield* getFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema);
+    for (const result of compareMaps(view.nodeSchema, stored.nodeSchema)) {
+        switch (result.type) {
+            case "aExtra": {
+                const viewType = getNodeSchemaType(result.value);
+                yield {
+                    identifier: result.key,
                     mismatch: "nodeKind",
-                    view: "object",
+                    view: viewType,
                     stored: undefined,
-                });
-            }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                (0, internal_1.assert)(storedNodeSchema !== undefined, 0x9be /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof index_js_1.MapNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "object",
-                        stored: "map",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "object",
-                        stored: "leaf",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
-                    const differences = trackObjectNodeDiscrepancies(viewNodeSchema, storedNodeSchema);
-                    if (differences.length > 0) {
-                        discrepancies.push({
-                            identifier: key,
-                            mismatch: "fields",
-                            differences,
-                        });
-                    }
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+                };
+                break;
             }
-        }
-        else if (viewNodeSchema instanceof index_js_1.MapNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                discrepancies.push({
-                    identifier: key,
+            case "bExtra": {
+                const storedType = getNodeSchemaType(result.value);
+                yield {
+                    identifier: result.key,
                     mismatch: "nodeKind",
-                    view: "map",
-                    stored: undefined,
-                });
+                    view: undefined,
+                    stored: storedType,
+                };
+                break;
             }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                (0, internal_1.assert)(storedNodeSchema !== undefined, 0x9bf /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "map",
-                        stored: "object",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "map",
-                        stored: "leaf",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.MapNodeStoredSchema) {
-                    discrepancies.push(...trackFieldDiscrepancies(viewNodeSchema.mapFields, storedNodeSchema.mapFields, key));
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+            case "both": {
+                yield* getNodeDiscrepancies(result.key, result.valueA, result.valueB);
+                break;
             }
+            default:
+                break;
         }
-        else if (viewNodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                discrepancies.push({
-                    identifier: key,
-                    mismatch: "nodeKind",
-                    view: "leaf",
-                    stored: undefined,
-                });
-            }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                (0, internal_1.assert)(storedNodeSchema !== undefined, 0x9c0 /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof index_js_1.MapNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "leaf",
-                        stored: "map",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
-                    discrepancies.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "leaf",
-                        stored: "object",
-                    });
-                }
-                else if (storedNodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
-                    if (viewNodeSchema.leafValue !== storedNodeSchema.leafValue) {
-                        discrepancies.push({
-                            identifier: key,
-                            mismatch: "valueSchema",
-                            view: viewNodeSchema.leafValue,
-                            stored: storedNodeSchema.leafValue,
-                        });
-                    }
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+    }
+}
+exports.getAllowedContentDiscrepancies = getAllowedContentDiscrepancies;
+function* getNodeDiscrepancies(identifier, view, stored) {
+    const viewType = getNodeSchemaType(view);
+    const storedType = getNodeSchemaType(stored);
+    if (viewType !== storedType) {
+        yield {
+            identifier,
+            mismatch: "nodeKind",
+            view: viewType,
+            stored: storedType,
+        };
+        return;
+    }
+    switch (viewType) {
+        case "object": {
+            const differences = Array.from(trackObjectNodeDiscrepancies(view, stored));
+            if (differences.length > 0) {
+                yield {
+                    identifier,
+                    mismatch: "fields",
+                    differences,
+                };
             }
+            break;
         }
-        else {
-            throwUnsupportedNodeType(viewNodeSchema.constructor.name);
-        }
-    }
-    for (const [key, storedNodeSchema] of stored.nodeSchema) {
-        if (!viewNodeKeys.has(key)) {
-            discrepancies.push({
-                identifier: key,
-                mismatch: "nodeKind",
-                view: undefined,
-                stored: storedNodeSchema instanceof index_js_1.MapNodeStoredSchema
-                    ? "map"
-                    : storedNodeSchema instanceof index_js_1.ObjectNodeStoredSchema
-                        ? "object"
-                        : "leaf",
-            });
+        case "map":
+            yield* getFieldDiscrepancies(view.mapFields, stored.mapFields, identifier);
+            break;
+        case "leaf": {
+            const viewValue = view.leafValue;
+            const storedValue = stored.leafValue;
+            if (viewValue !== storedValue) {
+                yield {
+                    identifier,
+                    mismatch: "valueSchema",
+                    view: viewValue,
+                    stored: storedValue,
+                };
+            }
+            break;
         }
+        default:
+            break;
     }
-    return discrepancies;
 }
-exports.getAllowedContentDiscrepancies = getAllowedContentDiscrepancies;
 /**
  * The function to track the discrepancies between two field stored schemas.
  *
  * @param keyOrRoot - If the key is missing, it indicates that this is the root field schema.
  */
-function trackFieldDiscrepancies(view, stored, keyOrRoot) {
-    const differences = [];
+function* getFieldDiscrepancies(view, stored, keyOrRoot) {
     // Only track the symmetric differences of two sets.
     const findSetDiscrepancies = (a, b) => {
         const aDiff = [...a].filter((value) => !b.has(value));
         const bDiff = [...b].filter((value) => !a.has(value));
         return [aDiff, bDiff];
     };
-    const allowedTypesDiscrepancies = findSetDiscrepancies(view.types, stored.types);
-    if (allowedTypesDiscrepancies[0].length > 0 || allowedTypesDiscrepancies[1].length > 0) {
-        differences.push({
+    const [viewExtra, storedExtra] = findSetDiscrepancies(view.types, stored.types);
+    if (viewExtra.length > 0 || storedExtra.length > 0) {
+        yield {
             identifier: keyOrRoot,
             mismatch: "allowedTypes",
-            view: allowedTypesDiscrepancies[0],
-            stored: allowedTypesDiscrepancies[1],
-        });
+            view: viewExtra,
+            stored: storedExtra,
+        };
     }
     if (view.kind !== stored.kind) {
-        differences.push({
+        yield {
             identifier: keyOrRoot,
             mismatch: "fieldKind",
             view: view.kind,
             stored: stored.kind,
-        });
+        };
     }
-    return differences;
 }
-function trackObjectNodeDiscrepancies(view, stored) {
-    const differences = [];
-    const viewFieldKeys = new Set();
+function* trackObjectNodeDiscrepancies(view, stored) {
     /**
      * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
      * three types of differences:
@@ -222,35 +157,59 @@ function trackObjectNodeDiscrepancies(view, stored) {
      * 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.
      */
-    for (const [fieldKey, fieldStoredSchema] of view.objectNodeFields) {
-        viewFieldKeys.add(fieldKey);
-        if (!stored.objectNodeFields.has(fieldKey) &&
-            fieldStoredSchema.kind !== index_js_1.storedEmptyFieldSchema.kind) {
-            differences.push({
-                identifier: fieldKey,
-                mismatch: "fieldKind",
-                view: fieldStoredSchema.kind,
-                stored: index_js_1.storedEmptyFieldSchema.kind,
-            });
-        }
-        else {
-            differences.push(...trackFieldDiscrepancies(view.objectNodeFields.get(fieldKey), stored.objectNodeFields.get(fieldKey), fieldKey));
+    for (const result of compareMaps(view.objectNodeFields, stored.objectNodeFields)) {
+        const fieldKey = result.key;
+        switch (result.type) {
+            case "aExtra": {
+                if (result.value.kind === index_js_1.storedEmptyFieldSchema.kind) {
+                    // In one of view/stored, this field is explicitly forbidden, but in the other it is implicitly forbidden
+                    // (by way of omission). We treat these identically anyway.
+                    break;
+                }
+                yield {
+                    identifier: fieldKey,
+                    mismatch: "fieldKind",
+                    view: result.value.kind,
+                    stored: index_js_1.storedEmptyFieldSchema.kind,
+                };
+                break;
+            }
+            case "bExtra": {
+                if (result.value.kind === index_js_1.storedEmptyFieldSchema.kind) {
+                    // In one of view/stored, this field is explicitly forbidden, but in the other it is implicitly forbidden
+                    // (by way of omission). We treat these identically anyway.
+                    break;
+                }
+                yield {
+                    identifier: fieldKey,
+                    mismatch: "fieldKind",
+                    view: index_js_1.storedEmptyFieldSchema.kind,
+                    stored: result.value.kind,
+                };
+                break;
+            }
+            case "both": {
+                yield* getFieldDiscrepancies(result.valueA, result.valueB, fieldKey);
+                break;
+            }
+            default: {
+                break;
+            }
         }
     }
-    for (const [fieldKey, fieldStoredSchema] of stored.objectNodeFields) {
-        if (viewFieldKeys.has(fieldKey)) {
-            continue;
-        }
-        if (fieldStoredSchema.kind !== index_js_1.storedEmptyFieldSchema.kind) {
-            differences.push({
-                identifier: fieldKey,
-                mismatch: "fieldKind",
-                view: index_js_1.storedEmptyFieldSchema.kind,
-                stored: fieldStoredSchema.kind,
-            });
+}
+function* compareMaps(a, b) {
+    for (const [key, valueA] of a) {
+        const valueB = b.get(key);
+        yield valueB === undefined
+            ? { type: "aExtra", key, value: valueA }
+            : { type: "both", key, valueA, valueB };
+    }
+    for (const [key, valueB] of b) {
+        if (!a.has(key)) {
+            yield { type: "bExtra", key, value: valueB };
         }
     }
-    return differences;
 }
 /**
  * @remarks
@@ -283,13 +242,13 @@ function isRepoSuperset(view, stored) {
             case "valueSchema":
             case "allowedTypes":
             case "fieldKind": {
-                if (!validateFieldIncompatibility(discrepancy)) {
+                if (!isFieldDiscrepancyCompatible(discrepancy)) {
                     return false;
                 }
                 break;
             }
             case "fields": {
-                if (discrepancy.differences.some((difference) => !validateFieldIncompatibility(difference))) {
+                if (discrepancy.differences.some((difference) => !isFieldDiscrepancyCompatible(difference))) {
                     return false;
                 }
                 break;
@@ -300,7 +259,7 @@ function isRepoSuperset(view, stored) {
     return true;
 }
 exports.isRepoSuperset = isRepoSuperset;
-function validateFieldIncompatibility(discrepancy) {
+function isFieldDiscrepancyCompatible(discrepancy) {
     switch (discrepancy.mismatch) {
         case "allowedTypes": {
             // Since we only track the symmetric difference between the allowed types in the view and
@@ -377,7 +336,7 @@ function comparePosetElements(a, b, realizer) {
     for (const extension of realizer) {
         const aIndex = extension.get(a);
         const bIndex = extension.get(b);
-        (0, internal_1.assert)(aIndex !== undefined && bIndex !== undefined, "Invalid realizer");
+        (0, internal_1.assert)(aIndex !== undefined && bIndex !== undefined, 0xa72 /* Invalid realizer */);
         if (aIndex < bIndex) {
             hasLessThanResult = true;
         }