@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/mapTreeCursor.js

@@ -0,0 +1,53 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTreeFromCursor = exports.cursorForMapTreeField = exports.cursorForMapTreeNode = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../core");
+const treeCursorUtils_1 = require("./treeCursorUtils");
+/**
+ * @returns An {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
+ */
+function cursorForMapTreeNode(root) {
+    return (0, treeCursorUtils_1.stackTreeNodeCursor)(adapter, root);
+}
+exports.cursorForMapTreeNode = cursorForMapTreeNode;
+/**
+ * @returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
+ */
+function cursorForMapTreeField(root, detachedField = core_1.rootField) {
+    const key = (0, core_1.detachedFieldAsKey)(detachedField);
+    return (0, treeCursorUtils_1.stackTreeFieldCursor)(adapter, {
+        type: core_1.aboveRootPlaceholder,
+        fields: new Map([[key, root]]),
+    }, detachedField);
+}
+exports.cursorForMapTreeField = cursorForMapTreeField;
+const adapter = {
+    value: (node) => node.value,
+    type: (node) => node.type,
+    keysFromNode: (node) => [...node.fields.keys()],
+    getFieldFromNode: (node, key) => node.fields.get(key) ?? [],
+};
+/**
+ * Extract a MapTree from the contents of the given ITreeCursor's current node.
+ */
+function mapTreeFromCursor(cursor) {
+    (0, core_utils_1.assert)(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x3b7 /* must start at node */);
+    const fields = new Map();
+    for (let inField = cursor.firstField(); inField; inField = cursor.nextField()) {
+        const field = (0, core_1.mapCursorField)(cursor, mapTreeFromCursor);
+        fields.set(cursor.getFieldKey(), field);
+    }
+    const node = {
+        type: cursor.type,
+        value: cursor.value,
+        fields,
+    };
+    return node;
+}
+exports.mapTreeFromCursor = mapTreeFromCursor;
+//# sourceMappingURL=mapTreeCursor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapTreeCursor.js","sourceRoot":"","sources":["../../src/feature-libraries/mapTreeCursor.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AACpD,kCAUiB;AACjB,uDAK2B;AAE3B;;GAEG;AACH,SAAgB,oBAAoB,CAAC,IAAa;IACjD,OAAO,IAAA,qCAAmB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AAFD,oDAEC;AAED;;GAEG;AACH,SAAgB,qBAAqB,CACpC,IAAe,EACf,gBAA+B,gBAAS;IAExC,MAAM,GAAG,GAAG,IAAA,yBAAkB,EAAC,aAAa,CAAC,CAAC;IAC9C,OAAO,IAAA,sCAAoB,EAC1B,OAAO,EACP;QACC,IAAI,EAAE,2BAAoB;QAC1B,MAAM,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;KAC9B,EACD,aAAa,CACb,CAAC;AACH,CAAC;AAbD,sDAaC;AAED,MAAM,OAAO,GAA2B;IACvC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK;IAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI;IACzB,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IAC/C,gBAAgB,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE;CAC3D,CAAC;AAEF;;GAEG;AACH,SAAgB,iBAAiB,CAAC,MAAmB;IACpD,IAAA,mBAAM,EAAC,MAAM,CAAC,IAAI,qCAA6B,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;IACjF,MAAM,MAAM,GAA6B,IAAI,GAAG,EAAE,CAAC;IACnD,KAAK,IAAI,OAAO,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,EAAE;QAC9E,MAAM,KAAK,GAAc,IAAA,qBAAc,EAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;QACnE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,CAAC;KACxC;IAED,MAAM,IAAI,GAAY;QACrB,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,MAAM;KACN,CAAC;IAEF,OAAO,IAAI,CAAC;AACb,CAAC;AAfD,8CAeC","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\";\nimport {\n\tFieldKey,\n\tMapTree,\n\tITreeCursor,\n\tCursorLocationType,\n\tmapCursorField,\n\tDetachedField,\n\tdetachedFieldAsKey,\n\trootField,\n\taboveRootPlaceholder,\n} from \"../core\";\nimport {\n\tCursorAdapter,\n\tCursorWithNode,\n\tstackTreeFieldCursor,\n\tstackTreeNodeCursor,\n} from \"./treeCursorUtils\";\n\n/**\n * @returns An {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.\n */\nexport function cursorForMapTreeNode(root: MapTree): CursorWithNode<MapTree> {\n\treturn stackTreeNodeCursor(adapter, root);\n}\n\n/**\n * @returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.\n */\nexport function cursorForMapTreeField(\n\troot: MapTree[],\n\tdetachedField: DetachedField = rootField,\n): CursorWithNode<MapTree> {\n\tconst key = detachedFieldAsKey(detachedField);\n\treturn stackTreeFieldCursor(\n\t\tadapter,\n\t\t{\n\t\t\ttype: aboveRootPlaceholder,\n\t\t\tfields: new Map([[key, root]]),\n\t\t},\n\t\tdetachedField,\n\t);\n}\n\nconst adapter: CursorAdapter<MapTree> = {\n\tvalue: (node) => node.value,\n\ttype: (node) => node.type,\n\tkeysFromNode: (node) => [...node.fields.keys()], // TODO: don't convert this to array here.\n\tgetFieldFromNode: (node, key) => node.fields.get(key) ?? [],\n};\n\n/**\n * Extract a MapTree from the contents of the given ITreeCursor's current node.\n */\nexport function mapTreeFromCursor(cursor: ITreeCursor): MapTree {\n\tassert(cursor.mode === CursorLocationType.Nodes, 0x3b7 /* must start at node */);\n\tconst fields: Map<FieldKey, MapTree[]> = new Map();\n\tfor (let inField = cursor.firstField(); inField; inField = cursor.nextField()) {\n\t\tconst field: MapTree[] = mapCursorField(cursor, mapTreeFromCursor);\n\t\tfields.set(cursor.getFieldKey(), field);\n\t}\n\n\tconst node: MapTree = {\n\t\ttype: cursor.type,\n\t\tvalue: cursor.value,\n\t\tfields,\n\t};\n\n\treturn node;\n}\n"]}

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

@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangesetLocalId, RevisionTag } from "../core";
+/**
+ * A unique ID allocator that returns the output ID for the same input ID.
+ *
+ * @internal
+ */
+export interface MemoizedIdRangeAllocator {
+    /**
+     * A unique ID allocator that returns the output ID for the same input ID.
+     *
+     * "The same" here includes cases where a prior call allocated a range of IDs that partially or fully overlap with the
+     * current call.
+     * @param revision - The revision associated with the range of IDs to allocate.
+     * @param startId - The first ID to allocate.
+     * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.
+     */
+    allocate(revision: RevisionTag | undefined, startId: ChangesetLocalId, count?: number): IdRange[];
+    /**
+     * Allocates a new range of IDs.
+     *
+     * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.
+     */
+    mint(count?: number): ChangesetLocalId;
+}
+/**
+ * @internal
+ */
+export interface IdRange {
+    readonly first: ChangesetLocalId;
+    readonly count: number;
+}
+/**
+ * @internal
+ */
+export declare const MemoizedIdRangeAllocator: {
+    fromNextId(nextId?: number): MemoizedIdRangeAllocator;
+};
+//# sourceMappingURL=memoizedIdRangeAllocator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoizedIdRangeAllocator.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/memoizedIdRangeAllocator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAUxD;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;OAQG;IACH,QAAQ,CACP,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,OAAO,EAAE,gBAAgB,EACzB,KAAK,CAAC,EAAE,MAAM,GACZ,OAAO,EAAE,CAAC;IACb;;;;OAIG;IACH,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;wBACjB,MAAM,GAAO,wBAAwB;CAgExD,CAAC"}

package/dist/feature-libraries/memoizedIdRangeAllocator.js

@@ -0,0 +1,75 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedIdRangeAllocator = void 0;
+const util_1 = require("../util");
+/**
+ * @internal
+ */
+exports.MemoizedIdRangeAllocator = {
+    fromNextId(nextId = 0) {
+        const rangeMap = new Map();
+        let _nextId = nextId;
+        return {
+            allocate(key, startId, length) {
+                let count = length ?? 1;
+                const out = [];
+                const ranges = (0, util_1.getOrAddEmptyToMap)(rangeMap, key);
+                let currId = startId;
+                while (count > 0) {
+                    const firstRange = (0, util_1.getFirstEntryFromRangeMap)(ranges, currId, count);
+                    if (firstRange === undefined) {
+                        const newId = _nextId;
+                        _nextId += count;
+                        (0, util_1.setInRangeMap)(ranges, currId, count, newId);
+                        out.push({ first: (0, util_1.brand)(newId), count });
+                        count = 0;
+                    }
+                    else {
+                        const idRange = {
+                            first: (0, util_1.brand)(firstRange.value),
+                            count: firstRange.length,
+                        };
+                        if (currId < firstRange.start) {
+                            const countToAdd = firstRange.start - currId;
+                            (0, util_1.setInRangeMap)(ranges, currId, countToAdd, _nextId);
+                            out.push({ first: (0, util_1.brand)(_nextId), count: countToAdd });
+                            _nextId += countToAdd;
+                            currId += countToAdd;
+                            count -= countToAdd;
+                        }
+                        else if (firstRange.start < currId) {
+                            const countToTrim = currId - firstRange.start;
+                            idRange.first = (0, util_1.brand)(idRange.first + countToTrim);
+                            idRange.count -= countToTrim;
+                        }
+                        if (idRange.count > count) {
+                            idRange.count = count;
+                        }
+                        else if (idRange.count < count &&
+                            firstRange.value + firstRange.length === _nextId) {
+                            // The existing range can be extended
+                            _nextId += count - idRange.count;
+                            firstRange.length = count;
+                            idRange.count = count;
+                        }
+                        out.push(idRange);
+                        count -= idRange.count;
+                        currId += idRange.count;
+                    }
+                }
+                return out;
+            },
+            mint(length) {
+                const count = length ?? 1;
+                const out = _nextId;
+                _nextId += count;
+                return (0, util_1.brand)(out);
+            },
+        };
+    },
+};
+//# sourceMappingURL=memoizedIdRangeAllocator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoizedIdRangeAllocator.js","sourceRoot":"","sources":["../../src/feature-libraries/memoizedIdRangeAllocator.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 { ChangesetLocalId, RevisionTag } from \"../core\";\nimport {\n\tRangeMap,\n\tgetOrAddEmptyToMap,\n\tgetFirstEntryFromRangeMap,\n\tsetInRangeMap,\n\tMutable,\n\tbrand,\n} from \"../util\";\n\n/**\n * A unique ID allocator that returns the output ID for the same input ID.\n *\n * @internal\n */\nexport interface MemoizedIdRangeAllocator {\n\t/**\n\t * A unique ID allocator that returns the output ID for the same input ID.\n\t *\n\t * \"The same\" here includes cases where a prior call allocated a range of IDs that partially or fully overlap with the\n\t * current call.\n\t * @param revision - The revision associated with the range of IDs to allocate.\n\t * @param startId - The first ID to allocate.\n\t * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.\n\t */\n\tallocate(\n\t\trevision: RevisionTag | undefined,\n\t\tstartId: ChangesetLocalId,\n\t\tcount?: number,\n\t): IdRange[];\n\t/**\n\t * Allocates a new range of IDs.\n\t *\n\t * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.\n\t */\n\tmint(count?: number): ChangesetLocalId;\n}\n\n/**\n * @internal\n */\nexport interface IdRange {\n\treadonly first: ChangesetLocalId;\n\treadonly count: number;\n}\n\n/**\n * @internal\n */\nexport const MemoizedIdRangeAllocator = {\n\tfromNextId(nextId: number = 0): MemoizedIdRangeAllocator {\n\t\tconst rangeMap: Map<RevisionTag | undefined, RangeMap<number>> = new Map();\n\t\tlet _nextId = nextId;\n\t\treturn {\n\t\t\tallocate(\n\t\t\t\tkey: string | number | undefined,\n\t\t\t\tstartId: number,\n\t\t\t\tlength?: number,\n\t\t\t): IdRange[] {\n\t\t\t\tlet count = length ?? 1;\n\t\t\t\tconst out: IdRange[] = [];\n\t\t\t\tconst ranges = getOrAddEmptyToMap(rangeMap, key);\n\t\t\t\tlet currId = startId;\n\t\t\t\twhile (count > 0) {\n\t\t\t\t\tconst firstRange = getFirstEntryFromRangeMap(ranges, currId, count);\n\t\t\t\t\tif (firstRange === undefined) {\n\t\t\t\t\t\tconst newId = _nextId;\n\t\t\t\t\t\t_nextId += count;\n\t\t\t\t\t\tsetInRangeMap(ranges, currId, count, newId);\n\t\t\t\t\t\tout.push({ first: brand(newId), count });\n\t\t\t\t\t\tcount = 0;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst idRange: Mutable<IdRange> = {\n\t\t\t\t\t\t\tfirst: brand(firstRange.value),\n\t\t\t\t\t\t\tcount: firstRange.length,\n\t\t\t\t\t\t};\n\t\t\t\t\t\tif (currId < firstRange.start) {\n\t\t\t\t\t\t\tconst countToAdd = firstRange.start - currId;\n\t\t\t\t\t\t\tsetInRangeMap(ranges, currId, countToAdd, _nextId);\n\t\t\t\t\t\t\tout.push({ first: brand(_nextId), count: countToAdd });\n\t\t\t\t\t\t\t_nextId += countToAdd;\n\t\t\t\t\t\t\tcurrId += countToAdd;\n\t\t\t\t\t\t\tcount -= countToAdd;\n\t\t\t\t\t\t} else if (firstRange.start < currId) {\n\t\t\t\t\t\t\tconst countToTrim = currId - firstRange.start;\n\t\t\t\t\t\t\tidRange.first = brand((idRange.first as number) + countToTrim);\n\t\t\t\t\t\t\tidRange.count -= countToTrim;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (idRange.count > count) {\n\t\t\t\t\t\t\tidRange.count = count;\n\t\t\t\t\t\t} else if (\n\t\t\t\t\t\t\tidRange.count < count &&\n\t\t\t\t\t\t\tfirstRange.value + firstRange.length === _nextId\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t// The existing range can be extended\n\t\t\t\t\t\t\t_nextId += count - idRange.count;\n\t\t\t\t\t\t\tfirstRange.length = count;\n\t\t\t\t\t\t\tidRange.count = count;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tout.push(idRange);\n\t\t\t\t\t\tcount -= idRange.count;\n\t\t\t\t\t\tcurrId += idRange.count;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn out;\n\t\t\t},\n\t\t\tmint(length?: number): ChangesetLocalId {\n\t\t\t\tconst count = length ?? 1;\n\t\t\t\tconst out = _nextId;\n\t\t\t\t_nextId += count;\n\t\t\t\treturn brand(out);\n\t\t\t},\n\t\t};\n\t},\n};\n"]}

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

@@ -0,0 +1,22 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangeFamily, ChangeFamilyEditor, ChangeRebaser } from "../core";
+/**
+ * Makes a given `ChangeFamily` safer to use by wrapping some of its functions in try-catch blocks.
+ *
+ * Mitigated functions:
+ * - {@link ChangeFamily.intoDelta} (an empty Delta is returned instead)
+ * - {@link ChangeRebaser.rebase} (the given `fallbackChange` is returned instead)
+ * - {@link ChangeRebaser.invert} (the given `fallbackChange` is returned instead)
+ * - {@link ChangeRebaser.compose} (the given `fallbackChange` is returned instead)
+ *
+ * @param unmitigatedChangeFamily - The change family to mitigate.
+ * @param fallbackChange - A changeset to use as a fallback when one of the mitigated functions throws.
+ * @param onError - A callback invoked for each error thrown.
+ * @returns a mitigated change family.
+ */
+export declare function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TChange>(unmitigatedChangeFamily: ChangeFamily<TEditor, TChange>, fallbackChange: TChange, onError: (error: unknown) => void): ChangeFamily<TEditor, TChange>;
+export declare function makeMitigatedRebaser<TChange>(unmitigatedRebaser: ChangeRebaser<TChange>, fallbackChange: TChange, onError: (error: unknown) => void): ChangeRebaser<TChange>;
+//# sourceMappingURL=mitigatedChangeFamily.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mitigatedChangeFamily.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/mitigatedChangeFamily.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,aAAa,EAGb,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,SAAS,kBAAkB,EAAE,OAAO,EACpF,uBAAuB,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACvD,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAC/B,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAQhC;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAC3C,kBAAkB,EAAE,aAAa,CAAC,OAAO,CAAC,EAC1C,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAC/B,aAAa,CAAC,OAAO,CAAC,CAyBxB"}

package/dist/feature-libraries/mitigatedChangeFamily.js

@@ -0,0 +1,55 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMitigatedRebaser = exports.makeMitigatedChangeFamily = void 0;
+/**
+ * Makes a given `ChangeFamily` safer to use by wrapping some of its functions in try-catch blocks.
+ *
+ * Mitigated functions:
+ * - {@link ChangeFamily.intoDelta} (an empty Delta is returned instead)
+ * - {@link ChangeRebaser.rebase} (the given `fallbackChange` is returned instead)
+ * - {@link ChangeRebaser.invert} (the given `fallbackChange` is returned instead)
+ * - {@link ChangeRebaser.compose} (the given `fallbackChange` is returned instead)
+ *
+ * @param unmitigatedChangeFamily - The change family to mitigate.
+ * @param fallbackChange - A changeset to use as a fallback when one of the mitigated functions throws.
+ * @param onError - A callback invoked for each error thrown.
+ * @returns a mitigated change family.
+ */
+function makeMitigatedChangeFamily(unmitigatedChangeFamily, fallbackChange, onError) {
+    return {
+        buildEditor: (changeReceiver) => {
+            return unmitigatedChangeFamily.buildEditor(changeReceiver);
+        },
+        rebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),
+        codecs: unmitigatedChangeFamily.codecs,
+    };
+}
+exports.makeMitigatedChangeFamily = makeMitigatedChangeFamily;
+function makeMitigatedRebaser(unmitigatedRebaser, fallbackChange, onError) {
+    const withFallback = (fn) => {
+        try {
+            return fn();
+        }
+        catch (error) {
+            onError(error);
+            return fallbackChange;
+        }
+    };
+    return {
+        compose: (changes) => {
+            return withFallback(() => unmitigatedRebaser.compose(changes));
+        },
+        invert: (changes, isRollback) => {
+            return withFallback(() => unmitigatedRebaser.invert(changes, isRollback));
+        },
+        rebase: (change, over, revisionMetadata) => {
+            return withFallback(() => unmitigatedRebaser.rebase(change, over, revisionMetadata));
+        },
+    };
+}
+exports.makeMitigatedRebaser = makeMitigatedRebaser;
+//# sourceMappingURL=mitigatedChangeFamily.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mitigatedChangeFamily.js","sourceRoot":"","sources":["../../src/feature-libraries/mitigatedChangeFamily.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAUH;;;;;;;;;;;;;GAaG;AACH,SAAgB,yBAAyB,CACxC,uBAAuD,EACvD,cAAuB,EACvB,OAAiC;IAEjC,OAAO;QACN,WAAW,EAAE,CAAC,cAAyC,EAAW,EAAE;YACnE,OAAO,uBAAuB,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,EAAE,oBAAoB,CAAC,uBAAuB,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC;QACvF,MAAM,EAAE,uBAAuB,CAAC,MAAM;KACtC,CAAC;AACH,CAAC;AAZD,8DAYC;AAED,SAAgB,oBAAoB,CACnC,kBAA0C,EAC1C,cAAuB,EACvB,OAAiC;IAEjC,MAAM,YAAY,GAAG,CAAC,EAAiB,EAAW,EAAE;QACnD,IAAI;YACH,OAAO,EAAE,EAAE,CAAC;SACZ;QAAC,OAAO,KAAc,EAAE;YACxB,OAAO,CAAC,KAAK,CAAC,CAAC;YACf,OAAO,cAAc,CAAC;SACtB;IACF,CAAC,CAAC;IAEF,OAAO;QACN,OAAO,EAAE,CAAC,OAAgC,EAAW,EAAE;YACtD,OAAO,YAAY,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QAChE,CAAC;QACD,MAAM,EAAE,CAAC,OAA8B,EAAE,UAAmB,EAAW,EAAE;YACxE,OAAO,YAAY,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;QAC3E,CAAC;QACD,MAAM,EAAE,CACP,MAAe,EACf,IAA2B,EAC3B,gBAAwC,EAC9B,EAAE;YACZ,OAAO,YAAY,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC;QACtF,CAAC;KACD,CAAC;AACH,CAAC;AA7BD,oDA6BC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tChangeFamily,\n\tChangeFamilyEditor,\n\tChangeRebaser,\n\tRevisionMetadataSource,\n\tTaggedChange,\n} from \"../core\";\n\n/**\n * Makes a given `ChangeFamily` safer to use by wrapping some of its functions in try-catch blocks.\n *\n * Mitigated functions:\n * - {@link ChangeFamily.intoDelta} (an empty Delta is returned instead)\n * - {@link ChangeRebaser.rebase} (the given `fallbackChange` is returned instead)\n * - {@link ChangeRebaser.invert} (the given `fallbackChange` is returned instead)\n * - {@link ChangeRebaser.compose} (the given `fallbackChange` is returned instead)\n *\n * @param unmitigatedChangeFamily - The change family to mitigate.\n * @param fallbackChange - A changeset to use as a fallback when one of the mitigated functions throws.\n * @param onError - A callback invoked for each error thrown.\n * @returns a mitigated change family.\n */\nexport function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TChange>(\n\tunmitigatedChangeFamily: ChangeFamily<TEditor, TChange>,\n\tfallbackChange: TChange,\n\tonError: (error: unknown) => void,\n): ChangeFamily<TEditor, TChange> {\n\treturn {\n\t\tbuildEditor: (changeReceiver: (change: TChange) => void): TEditor => {\n\t\t\treturn unmitigatedChangeFamily.buildEditor(changeReceiver);\n\t\t},\n\t\trebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),\n\t\tcodecs: unmitigatedChangeFamily.codecs,\n\t};\n}\n\nexport function makeMitigatedRebaser<TChange>(\n\tunmitigatedRebaser: ChangeRebaser<TChange>,\n\tfallbackChange: TChange,\n\tonError: (error: unknown) => void,\n): ChangeRebaser<TChange> {\n\tconst withFallback = (fn: () => TChange): TChange => {\n\t\ttry {\n\t\t\treturn fn();\n\t\t} catch (error: unknown) {\n\t\t\tonError(error);\n\t\t\treturn fallbackChange;\n\t\t}\n\t};\n\n\treturn {\n\t\tcompose: (changes: TaggedChange<TChange>[]): TChange => {\n\t\t\treturn withFallback(() => unmitigatedRebaser.compose(changes));\n\t\t},\n\t\tinvert: (changes: TaggedChange<TChange>, isRollback: boolean): TChange => {\n\t\t\treturn withFallback(() => unmitigatedRebaser.invert(changes, isRollback));\n\t\t},\n\t\trebase: (\n\t\t\tchange: TChange,\n\t\t\tover: TaggedChange<TChange>,\n\t\t\trevisionMetadata: RevisionMetadataSource,\n\t\t): TChange => {\n\t\t\treturn withFallback(() => unmitigatedRebaser.rebase(change, over, revisionMetadata));\n\t\t},\n\t};\n}\n"]}

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

@@ -0,0 +1,63 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TreeNodeStoredSchema, ValueSchema, TreeFieldStoredSchema, TreeTypeSet, TreeStoredSchema } from "../../core";
+import { FullSchemaPolicy } from "./fieldKind";
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ *
+ * `undefined` TreeNodeStoredSchema means the schema is not present (and thus treated as a NeverTree).
+ */
+export declare function allowsTreeSuperset(policy: FullSchemaPolicy, originalData: TreeStoredSchema, original: TreeNodeStoredSchema | undefined, superset: TreeNodeStoredSchema | undefined): boolean;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+export declare function allowsValueSuperset(original: ValueSchema | undefined, superset: ValueSchema | undefined): boolean;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+export declare function allowsFieldSuperset(policy: FullSchemaPolicy, originalData: TreeStoredSchema, original: TreeFieldStoredSchema, superset: TreeFieldStoredSchema): boolean;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+export declare function allowsTreeSchemaIdentifierSuperset(original: TreeTypeSet, superset: TreeTypeSet): boolean;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ *
+ * A version of this that assumes a specific root field could be slightly more permissive in some simple cases,
+ * however if any extra fields and fields with unconstrained types are reachable,
+ * it would have to compare everything anyway.
+ */
+export declare function allowsRepoSuperset(policy: FullSchemaPolicy, original: TreeStoredSchema, superset: TreeStoredSchema): boolean;
+/**
+ * @internal
+ */
+export declare function isNeverField(policy: FullSchemaPolicy, originalData: TreeStoredSchema, field: TreeFieldStoredSchema): boolean;
+export declare function isNeverFieldRecursive(policy: FullSchemaPolicy, originalData: TreeStoredSchema, field: TreeFieldStoredSchema, parentTypeStack: Set<TreeNodeStoredSchema>): boolean;
+/**
+ * Returns true iff there are no possible trees that could meet this schema.
+ * Trees which are infinite (like endless linked lists) are considered impossible.
+ *
+ * `undefined` means the schema is not present and thus a NeverTree.
+ */
+export declare function isNeverTree(policy: FullSchemaPolicy, originalData: TreeStoredSchema, treeNode: TreeNodeStoredSchema | undefined): boolean;
+/**
+ * Returns true iff there are no possible trees that could meet this schema.
+ * Trees which are infinite (like endless linked lists) are considered impossible.
+ *
+ * `undefined` means the schema is not present and thus a NeverTree.
+ */
+export declare function isNeverTreeRecursive(policy: FullSchemaPolicy, originalData: TreeStoredSchema, treeNode: TreeNodeStoredSchema | undefined, parentTypeStack: Set<TreeNodeStoredSchema>): boolean;
+export declare function normalizeField(schema: TreeFieldStoredSchema | undefined): TreeFieldStoredSchema;
+//# sourceMappingURL=comparison.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/comparison.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,oBAAoB,EACpB,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,gBAAgB,EAKhB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAc,MAAM,aAAa,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,oBAAoB,GAAG,SAAS,EAC1C,QAAQ,EAAE,oBAAoB,GAAG,SAAS,GACxC,OAAO,CAgFT;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,QAAQ,EAAE,WAAW,GAAG,SAAS,GAC/B,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,qBAAqB,EAC/B,QAAQ,EAAE,qBAAqB,GAC7B,OAAO,CAIT;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CACjD,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,WAAW,GACnB,OAAO,CAaT;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACxB,OAAO,CAqBT;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,KAAK,EAAE,qBAAqB,GAC1B,OAAO,CAET;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,KAAK,EAAE,qBAAqB,EAC5B,eAAe,EAAE,GAAG,CAAC,oBAAoB,CAAC,GACxC,OAAO,CAuBT;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,oBAAoB,GAAG,SAAS,GACxC,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,oBAAoB,GAAG,SAAS,EAC1C,eAAe,EAAE,GAAG,CAAC,oBAAoB,CAAC,GACxC,OAAO,CAkCT;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,GAAG,qBAAqB,CAE/F"}

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

@@ -0,0 +1,203 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeField = exports.isNeverTreeRecursive = exports.isNeverTree = exports.isNeverFieldRecursive = exports.isNeverField = exports.allowsRepoSuperset = exports.allowsTreeSchemaIdentifierSuperset = exports.allowsFieldSuperset = exports.allowsValueSuperset = exports.allowsTreeSuperset = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const util_1 = require("../../util");
+const core_1 = require("../../core");
+const multiplicity_1 = require("../multiplicity");
+const fieldKind_1 = require("./fieldKind");
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ *
+ * `undefined` TreeNodeStoredSchema means the schema is not present (and thus treated as a NeverTree).
+ */
+function allowsTreeSuperset(policy, originalData, original, superset) {
+    if (isNeverTree(policy, originalData, original)) {
+        return true;
+    }
+    if (isNeverTree(policy, originalData, superset)) {
+        return false;
+    }
+    (0, core_utils_1.assert)(original !== undefined, 0x716 /* only never trees have undefined schema */);
+    (0, core_utils_1.assert)(superset !== undefined, 0x717 /* only never trees have undefined schema */);
+    if (original instanceof core_1.LeafNodeStoredSchema) {
+        if (superset instanceof core_1.LeafNodeStoredSchema) {
+            return allowsValueSuperset(original.leafValue, superset.leafValue);
+        }
+        return false;
+    }
+    (0, core_utils_1.assert)(original instanceof core_1.MapNodeStoredSchema || original instanceof core_1.ObjectNodeStoredSchema, "unsupported node kind");
+    (0, core_utils_1.assert)(superset instanceof core_1.MapNodeStoredSchema || superset instanceof core_1.ObjectNodeStoredSchema, "unsupported node kind");
+    if (original instanceof core_1.MapNodeStoredSchema) {
+        if (superset instanceof core_1.MapNodeStoredSchema) {
+            return allowsFieldSuperset(policy, originalData, normalizeField(original.mapFields), normalizeField(superset.mapFields));
+        }
+        return false;
+    }
+    (0, core_utils_1.assert)(original instanceof core_1.ObjectNodeStoredSchema, "unsupported node kind");
+    if (superset instanceof core_1.MapNodeStoredSchema) {
+        for (const [_key, field] of original.objectNodeFields) {
+            if (!allowsFieldSuperset(policy, originalData, normalizeField(field), normalizeField(superset.mapFields))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    (0, core_utils_1.assert)(superset instanceof core_1.ObjectNodeStoredSchema, "unsupported node kind");
+    return (0, util_1.compareSets)({
+        a: original.objectNodeFields,
+        b: superset.objectNodeFields,
+        aExtra: (originalField) => allowsFieldSuperset(policy, originalData, original.objectNodeFields.get(originalField) ?? (0, util_1.fail)("missing expected field"), normalizeField(undefined)),
+        bExtra: (supersetField) => allowsFieldSuperset(policy, originalData, normalizeField(undefined), superset.objectNodeFields.get(supersetField) ?? (0, util_1.fail)("missing expected field")),
+        same: (sameField) => allowsFieldSuperset(policy, originalData, original.objectNodeFields.get(sameField) ?? (0, util_1.fail)("missing expected field"), superset.objectNodeFields.get(sameField) ?? (0, util_1.fail)("missing expected field")),
+    });
+}
+exports.allowsTreeSuperset = allowsTreeSuperset;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+function allowsValueSuperset(original, superset) {
+    return original === superset;
+}
+exports.allowsValueSuperset = allowsValueSuperset;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+function allowsFieldSuperset(policy, originalData, original, superset) {
+    return (0, fieldKind_1.withEditor)(policy.fieldKinds.get(original.kind.identifier) ?? (0, util_1.fail)("missing kind")).allowsFieldSuperset(policy, originalData, original.types, superset);
+}
+exports.allowsFieldSuperset = allowsFieldSuperset;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+function allowsTreeSchemaIdentifierSuperset(original, superset) {
+    if (superset === undefined) {
+        return true;
+    }
+    if (original === undefined) {
+        return false;
+    }
+    for (const originalType of original) {
+        if (!superset.has(originalType)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.allowsTreeSchemaIdentifierSuperset = allowsTreeSchemaIdentifierSuperset;
+/**
+ * @returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ *
+ * A version of this that assumes a specific root field could be slightly more permissive in some simple cases,
+ * however if any extra fields and fields with unconstrained types are reachable,
+ * it would have to compare everything anyway.
+ */
+function allowsRepoSuperset(policy, original, superset) {
+    {
+        // TODO: I think its ok to use the field from superset here, but I should confirm it is, and document why.
+        if (!allowsFieldSuperset(policy, original, original.rootFieldSchema, superset.rootFieldSchema)) {
+            return false;
+        }
+    }
+    for (const [key, schema] of original.nodeSchema) {
+        // TODO: I think its ok to use the tree from superset here, but I should confirm it is, and document why.
+        if (!allowsTreeSuperset(policy, original, schema, superset.nodeSchema.get(key))) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.allowsRepoSuperset = allowsRepoSuperset;
+/**
+ * @internal
+ */
+function isNeverField(policy, originalData, field) {
+    return isNeverFieldRecursive(policy, originalData, field, new Set());
+}
+exports.isNeverField = isNeverField;
+function isNeverFieldRecursive(policy, originalData, field, parentTypeStack) {
+    if ((policy.fieldKinds.get(field.kind.identifier) ?? (0, util_1.fail)("missing field kind"))
+        .multiplicity === multiplicity_1.Multiplicity.Single &&
+        field.types !== undefined) {
+        for (const type of field.types) {
+            if (!isNeverTreeRecursive(policy, originalData, originalData.nodeSchema.get(type), parentTypeStack)) {
+                return false;
+            }
+        }
+        // This field requires at least one child, and there are no types permitted in it that can exist,
+        // so this is a never field (field which no sequence of children content could ever be in schema for)
+        return true;
+    }
+    return false;
+}
+exports.isNeverFieldRecursive = isNeverFieldRecursive;
+/**
+ * Returns true iff there are no possible trees that could meet this schema.
+ * Trees which are infinite (like endless linked lists) are considered impossible.
+ *
+ * `undefined` means the schema is not present and thus a NeverTree.
+ */
+function isNeverTree(policy, originalData, treeNode) {
+    return isNeverTreeRecursive(policy, originalData, treeNode, new Set());
+}
+exports.isNeverTree = isNeverTree;
+/**
+ * Returns true iff there are no possible trees that could meet this schema.
+ * Trees which are infinite (like endless linked lists) are considered impossible.
+ *
+ * `undefined` means the schema is not present and thus a NeverTree.
+ */
+function isNeverTreeRecursive(policy, originalData, treeNode, parentTypeStack) {
+    if (treeNode === undefined) {
+        return true;
+    }
+    if (parentTypeStack.has(treeNode)) {
+        return true;
+    }
+    try {
+        parentTypeStack.add(treeNode);
+        if (treeNode instanceof core_1.MapNodeStoredSchema) {
+            return ((policy.fieldKinds.get(treeNode.mapFields.kind.identifier) ??
+                (0, util_1.fail)("missing field kind")).multiplicity === multiplicity_1.Multiplicity.Single);
+        }
+        else if (treeNode instanceof core_1.ObjectNodeStoredSchema) {
+            for (const field of treeNode.objectNodeFields.values()) {
+                // TODO: this can recurse infinitely for schema that include themselves in a value field.
+                // This breaks even if there are other allowed types.
+                // Such schema should either be rejected (as an error here) or considered never (and thus detected by this).
+                // This can be done by passing a set/stack of current types recursively here.
+                if (isNeverFieldRecursive(policy, originalData, field, parentTypeStack)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            (0, core_utils_1.assert)(treeNode instanceof core_1.LeafNodeStoredSchema, "unsupported node kind");
+            return false;
+        }
+    }
+    finally {
+        parentTypeStack.delete(treeNode);
+    }
+}
+exports.isNeverTreeRecursive = isNeverTreeRecursive;
+function normalizeField(schema) {
+    return schema ?? core_1.storedEmptyFieldSchema;
+}
+exports.normalizeField = normalizeField;
+//# sourceMappingURL=comparison.js.map

package/dist/feature-libraries/modular-schema/comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.js","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/comparison.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport { compareSets, fail } from \"../../util\";\nimport {\n\tTreeNodeStoredSchema,\n\tValueSchema,\n\tTreeFieldStoredSchema,\n\tTreeTypeSet,\n\tTreeStoredSchema,\n\tstoredEmptyFieldSchema,\n\tLeafNodeStoredSchema,\n\tMapNodeStoredSchema,\n\tObjectNodeStoredSchema,\n} from \"../../core\";\nimport { Multiplicity } from \"../multiplicity\";\nimport { FullSchemaPolicy, withEditor } from \"./fieldKind\";\n\n/**\n * @returns true iff `superset` is a superset of `original`.\n *\n * This does not require a strict (aka proper) superset: equivalent schema will return true.\n *\n * `undefined` TreeNodeStoredSchema means the schema is not present (and thus treated as a NeverTree).\n */\nexport function allowsTreeSuperset(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\toriginal: TreeNodeStoredSchema | undefined,\n\tsuperset: TreeNodeStoredSchema | undefined,\n): boolean {\n\tif (isNeverTree(policy, originalData, original)) {\n\t\treturn true;\n\t}\n\tif (isNeverTree(policy, originalData, superset)) {\n\t\treturn false;\n\t}\n\tassert(original !== undefined, 0x716 /* only never trees have undefined schema */);\n\tassert(superset !== undefined, 0x717 /* only never trees have undefined schema */);\n\tif (original instanceof LeafNodeStoredSchema) {\n\t\tif (superset instanceof LeafNodeStoredSchema) {\n\t\t\treturn allowsValueSuperset(original.leafValue, superset.leafValue);\n\t\t}\n\t\treturn false;\n\t}\n\n\tassert(\n\t\toriginal instanceof MapNodeStoredSchema || original instanceof ObjectNodeStoredSchema,\n\t\t\"unsupported node kind\",\n\t);\n\tassert(\n\t\tsuperset instanceof MapNodeStoredSchema || superset instanceof ObjectNodeStoredSchema,\n\t\t\"unsupported node kind\",\n\t);\n\n\tif (original instanceof MapNodeStoredSchema) {\n\t\tif (superset instanceof MapNodeStoredSchema) {\n\t\t\treturn allowsFieldSuperset(\n\t\t\t\tpolicy,\n\t\t\t\toriginalData,\n\t\t\t\tnormalizeField(original.mapFields),\n\t\t\t\tnormalizeField(superset.mapFields),\n\t\t\t);\n\t\t}\n\t\treturn false;\n\t}\n\n\tassert(original instanceof ObjectNodeStoredSchema, \"unsupported node kind\");\n\tif (superset instanceof MapNodeStoredSchema) {\n\t\tfor (const [_key, field] of original.objectNodeFields) {\n\t\t\tif (\n\t\t\t\t!allowsFieldSuperset(\n\t\t\t\t\tpolicy,\n\t\t\t\t\toriginalData,\n\t\t\t\t\tnormalizeField(field),\n\t\t\t\t\tnormalizeField(superset.mapFields),\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\tassert(superset instanceof ObjectNodeStoredSchema, \"unsupported node kind\");\n\n\treturn compareSets({\n\t\ta: original.objectNodeFields,\n\t\tb: superset.objectNodeFields,\n\t\taExtra: (originalField) =>\n\t\t\tallowsFieldSuperset(\n\t\t\t\tpolicy,\n\t\t\t\toriginalData,\n\t\t\t\toriginal.objectNodeFields.get(originalField) ?? fail(\"missing expected field\"),\n\t\t\t\tnormalizeField(undefined),\n\t\t\t),\n\t\tbExtra: (supersetField) =>\n\t\t\tallowsFieldSuperset(\n\t\t\t\tpolicy,\n\t\t\t\toriginalData,\n\t\t\t\tnormalizeField(undefined),\n\t\t\t\tsuperset.objectNodeFields.get(supersetField) ?? fail(\"missing expected field\"),\n\t\t\t),\n\t\tsame: (sameField) =>\n\t\t\tallowsFieldSuperset(\n\t\t\t\tpolicy,\n\t\t\t\toriginalData,\n\t\t\t\toriginal.objectNodeFields.get(sameField) ?? fail(\"missing expected field\"),\n\t\t\t\tsuperset.objectNodeFields.get(sameField) ?? fail(\"missing expected field\"),\n\t\t\t),\n\t});\n}\n\n/**\n * @returns true iff `superset` is a superset of `original`.\n *\n * This does not require a strict (aka proper) superset: equivalent schema will return true.\n */\nexport function allowsValueSuperset(\n\toriginal: ValueSchema | undefined,\n\tsuperset: ValueSchema | undefined,\n): boolean {\n\treturn original === superset;\n}\n\n/**\n * @returns true iff `superset` is a superset of `original`.\n *\n * This does not require a strict (aka proper) superset: equivalent schema will return true.\n */\nexport function allowsFieldSuperset(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\toriginal: TreeFieldStoredSchema,\n\tsuperset: TreeFieldStoredSchema,\n): boolean {\n\treturn withEditor(\n\t\tpolicy.fieldKinds.get(original.kind.identifier) ?? fail(\"missing kind\"),\n\t).allowsFieldSuperset(policy, originalData, original.types, superset);\n}\n\n/**\n * @returns true iff `superset` is a superset of `original`.\n *\n * This does not require a strict (aka proper) superset: equivalent schema will return true.\n */\nexport function allowsTreeSchemaIdentifierSuperset(\n\toriginal: TreeTypeSet,\n\tsuperset: TreeTypeSet,\n): boolean {\n\tif (superset === undefined) {\n\t\treturn true;\n\t}\n\tif (original === undefined) {\n\t\treturn false;\n\t}\n\tfor (const originalType of original) {\n\t\tif (!superset.has(originalType)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\n/**\n * @returns true iff `superset` is a superset of `original`.\n *\n * This does not require a strict (aka proper) superset: equivalent schema will return true.\n *\n * A version of this that assumes a specific root field could be slightly more permissive in some simple cases,\n * however if any extra fields and fields with unconstrained types are reachable,\n * it would have to compare everything anyway.\n */\nexport function allowsRepoSuperset(\n\tpolicy: FullSchemaPolicy,\n\toriginal: TreeStoredSchema,\n\tsuperset: TreeStoredSchema,\n): boolean {\n\t{\n\t\t// TODO: I think its ok to use the field from superset here, but I should confirm it is, and document why.\n\t\tif (\n\t\t\t!allowsFieldSuperset(\n\t\t\t\tpolicy,\n\t\t\t\toriginal,\n\t\t\t\toriginal.rootFieldSchema,\n\t\t\t\tsuperset.rootFieldSchema,\n\t\t\t)\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\t}\n\tfor (const [key, schema] of original.nodeSchema) {\n\t\t// TODO: I think its ok to use the tree from superset here, but I should confirm it is, and document why.\n\t\tif (!allowsTreeSuperset(policy, original, schema, superset.nodeSchema.get(key))) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\n/**\n * @internal\n */\nexport function isNeverField(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\tfield: TreeFieldStoredSchema,\n): boolean {\n\treturn isNeverFieldRecursive(policy, originalData, field, new Set());\n}\n\nexport function isNeverFieldRecursive(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\tfield: TreeFieldStoredSchema,\n\tparentTypeStack: Set<TreeNodeStoredSchema>,\n): boolean {\n\tif (\n\t\t(policy.fieldKinds.get(field.kind.identifier) ?? fail(\"missing field kind\"))\n\t\t\t.multiplicity === Multiplicity.Single &&\n\t\tfield.types !== undefined\n\t) {\n\t\tfor (const type of field.types) {\n\t\t\tif (\n\t\t\t\t!isNeverTreeRecursive(\n\t\t\t\t\tpolicy,\n\t\t\t\t\toriginalData,\n\t\t\t\t\toriginalData.nodeSchema.get(type),\n\t\t\t\t\tparentTypeStack,\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\t// This field requires at least one child, and there are no types permitted in it that can exist,\n\t\t// so this is a never field (field which no sequence of children content could ever be in schema for)\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/**\n * Returns true iff there are no possible trees that could meet this schema.\n * Trees which are infinite (like endless linked lists) are considered impossible.\n *\n * `undefined` means the schema is not present and thus a NeverTree.\n */\nexport function isNeverTree(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\ttreeNode: TreeNodeStoredSchema | undefined,\n): boolean {\n\treturn isNeverTreeRecursive(policy, originalData, treeNode, new Set());\n}\n\n/**\n * Returns true iff there are no possible trees that could meet this schema.\n * Trees which are infinite (like endless linked lists) are considered impossible.\n *\n * `undefined` means the schema is not present and thus a NeverTree.\n */\nexport function isNeverTreeRecursive(\n\tpolicy: FullSchemaPolicy,\n\toriginalData: TreeStoredSchema,\n\ttreeNode: TreeNodeStoredSchema | undefined,\n\tparentTypeStack: Set<TreeNodeStoredSchema>,\n): boolean {\n\tif (treeNode === undefined) {\n\t\treturn true;\n\t}\n\tif (parentTypeStack.has(treeNode)) {\n\t\treturn true;\n\t}\n\ttry {\n\t\tparentTypeStack.add(treeNode);\n\t\tif (treeNode instanceof MapNodeStoredSchema) {\n\t\t\treturn (\n\t\t\t\t(\n\t\t\t\t\tpolicy.fieldKinds.get(treeNode.mapFields.kind.identifier) ??\n\t\t\t\t\tfail(\"missing field kind\")\n\t\t\t\t).multiplicity === Multiplicity.Single\n\t\t\t);\n\t\t} else if (treeNode instanceof ObjectNodeStoredSchema) {\n\t\t\tfor (const field of treeNode.objectNodeFields.values()) {\n\t\t\t\t// TODO: this can recurse infinitely for schema that include themselves in a value field.\n\t\t\t\t// This breaks even if there are other allowed types.\n\t\t\t\t// Such schema should either be rejected (as an error here) or considered never (and thus detected by this).\n\t\t\t\t// This can be done by passing a set/stack of current types recursively here.\n\t\t\t\tif (isNeverFieldRecursive(policy, originalData, field, parentTypeStack)) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} else {\n\t\t\tassert(treeNode instanceof LeafNodeStoredSchema, \"unsupported node kind\");\n\t\t\treturn false;\n\t\t}\n\t} finally {\n\t\tparentTypeStack.delete(treeNode);\n\t}\n}\n\nexport function normalizeField(schema: TreeFieldStoredSchema | undefined): TreeFieldStoredSchema {\n\treturn schema ?? storedEmptyFieldSchema;\n}\n"]}

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

@@ -0,0 +1,37 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangesetLocalId, RevisionTag } from "../../core";
+import { RangeMap, RangeQueryResult } from "../../util";
+export type CrossFieldMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;
+export type CrossFieldQuerySet = CrossFieldMap<boolean>;
+export declare function addCrossFieldQuery(set: CrossFieldQuerySet, revision: RevisionTag | undefined, id: ChangesetLocalId, count: number): void;
+export declare function setInCrossFieldMap<T>(map: CrossFieldMap<T>, revision: RevisionTag | undefined, id: ChangesetLocalId, count: number, value: T): void;
+export declare function getFirstFromCrossFieldMap<T>(map: CrossFieldMap<T>, revision: RevisionTag | undefined, id: ChangesetLocalId, count: number): RangeQueryResult<T>;
+/**
+ * @internal
+ */
+export declare enum CrossFieldTarget {
+    Source = 0,
+    Destination = 1
+}
+/**
+ * Used by {@link FieldChangeHandler} implementations for exchanging information across other fields
+ * while rebasing, composing, or inverting a change.
+ * @internal
+ */
+export interface CrossFieldManager<T = unknown> {
+    /**
+     * Returns the first data range associated with the key of `target`, `revision`, between `id` and `id + count`.
+     * Calling this records a dependency for the current field on this key if `addDependency` is true.
+     */
+    get(target: CrossFieldTarget, revision: RevisionTag | undefined, id: ChangesetLocalId, count: number, addDependency: boolean): RangeQueryResult<T>;
+    /**
+     * Sets the range of keys to `newValue`.
+     * If `invalidateDependents` is true, all fields which took a dependency on this key will be considered invalidated
+     * and will be given a chance to address the new data in `amendCompose`, or a second pass of `rebase` or `invert` as appropriate.
+     */
+    set(target: CrossFieldTarget, revision: RevisionTag | undefined, id: ChangesetLocalId, count: number, newValue: T, invalidateDependents: boolean): void;
+}
+//# sourceMappingURL=crossFieldQueries.d.ts.map