@fluidframework/ai-collab 2.10.0-306579

package/lib/implicit-strategy/sharedTreeDiff.js

@@ -0,0 +1,515 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { NodeKind } from "@fluidframework/tree";
+import { isTreeMapNode, sharedTreeTraverse } from "./utils.js";
+const richTypes = { Date: true, RegExp: true, String: true, Number: true };
+/**
+ * By default, Object Diff supports cyclical references, but if you are sure that the object has no cycles like parsed JSON
+ * you can disable cycles by setting the cyclesFix option to false
+ */
+const DEFAULT_OPTIONS = { cyclesFix: true };
+/**
+ * Compares two objects and returns an array of differences between them.
+ *
+ * @alpha
+ */
+export function sharedTreeDiff(obj, newObj, options = DEFAULT_OPTIONS, _stack = []) {
+    const diffs = [];
+    const isObjArray = isArrayOrTreeArrayNode(obj);
+    const isNewObjArray = isArrayOrTreeArrayNode(newObj);
+    // If useObjectIds is set, we'll create a map of object ids to their index in the array.
+    const oldObjArrayItemIdsToIndex = isObjArray === false || options.useObjectIds === undefined
+        ? new Map()
+        : createObjectArrayItemIdsToIndexMap(obj, options.useObjectIds.idAttributeName);
+    const newObjArrayItemIdsToIndex = isNewObjArray === false || options.useObjectIds === undefined
+        ? new Map()
+        : createObjectArrayItemIdsToIndexMap(newObj, options.useObjectIds.idAttributeName);
+    const objectKeys = isTreeMapNode(obj) ? obj.keys() : Object.keys(obj);
+    // We compare existence and values of all attributes within the old against new object, looking for removals or changes.
+    for (const key of objectKeys) {
+        const objValue = isTreeMapNode(obj) ? obj.get(key) : obj[key];
+        const path = isObjArray ? +key : key;
+        // 1. First, check if the key within the old object, exists within the new object. If it doesn't exist this would be an attribute removal.
+        if (!(key in newObj)) {
+            if (options.useObjectIds === undefined) {
+                diffs.push({
+                    type: "REMOVE",
+                    path: [path],
+                    objectId: undefined,
+                    oldValue: objValue,
+                });
+                continue;
+            }
+            // If we're dealing with an object in an array, we can use the object's id to check if it was moved to a new index.
+            else if (isNewObjArray === true &&
+                isObjArray &&
+                typeof objValue === "object" &&
+                objValue !== null) {
+                const objectId = objValue[options.useObjectIds.idAttributeName];
+                if (objectId !== undefined && newObjArrayItemIdsToIndex.has(objectId)) {
+                    // The index no longer exists in the new root object array, however the object that lived at this index actually still exists at a new index.
+                    // Therefore, this node was moved to a new index.
+                    diffs.push({
+                        type: "MOVE",
+                        path: [path],
+                        newIndex: newObjArrayItemIdsToIndex.get(objectId),
+                        value: objValue,
+                        objectId,
+                    });
+                    continue;
+                }
+                // The object with the given id cannot be found within the new array, therefore it was removed.
+                else {
+                    diffs.push({
+                        type: "REMOVE",
+                        path: [path],
+                        objectId,
+                        oldValue: objValue,
+                    });
+                    continue;
+                }
+            }
+            // If we're not dealing with an object in an array, we can't use id's to check for a move.
+            // We'll assume that a missing key in the new object means that the cooresponding value was removed.
+            else {
+                diffs.push({
+                    type: "REMOVE",
+                    path: [path],
+                    objectId: undefined,
+                    oldValue: objValue,
+                });
+                continue;
+            }
+        }
+        const newObjValue = newObj[key];
+        const areCompatibleObjects = typeof objValue === "object" &&
+            typeof newObjValue === "object" &&
+            isArrayOrTreeArrayNode(objValue) === isArrayOrTreeArrayNode(newObjValue);
+        // 2a. If the given old object key exists in the new object, and the value of said key in both objects is ANOTHER nested object, we need to run a recursive diff check on them.
+        if (objValue !== null &&
+            newObjValue !== null &&
+            areCompatibleObjects &&
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/no-unsafe-member-access
+            !richTypes[Object.getPrototypeOf(objValue)?.constructor?.name] &&
+            (!options.cyclesFix || !_stack.includes(objValue))) {
+            if (options.useObjectIds === undefined) {
+                const nestedDiffs = sharedTreeDiff(objValue, newObjValue, options, options.cyclesFix === true
+                    ? [..._stack, objValue]
+                    : []);
+                // eslint-disable-next-line prefer-spread
+                diffs.push.apply(diffs, nestedDiffs.map((difference) => {
+                    difference.path.unshift(path);
+                    return difference;
+                }));
+            }
+            // Use Object Id strategy to determine if the objects should be compared for changes
+            else {
+                const oldObjectId = objValue[options.useObjectIds.idAttributeName];
+                const newObjectId = newObjValue[options.useObjectIds.idAttributeName];
+                if (oldObjectId !== undefined && newObjectId !== undefined) {
+                    // 2a.1 if the object id's are the same, we can continue a comparison between the two objects.
+                    if (oldObjectId === newObjectId) {
+                        const nestedDiffs = sharedTreeDiff(objValue, newObjValue, options, options.cyclesFix === true
+                            ? [..._stack, objValue]
+                            : []);
+                        diffs.push(...nestedDiffs.map((difference) => {
+                            difference.path.unshift(path);
+                            return difference;
+                        }));
+                    }
+                    // 2a.2 The object id's are different, their attributes cannot be compared.
+                    // We need to find the new index of the object, if it exists in the new array and do a diff comparison.
+                    else {
+                        const newIndexOfOldObject = newObjArrayItemIdsToIndex.get(oldObjectId);
+                        // The object no longer exists in the new array, therefore it was removed.
+                        if (newIndexOfOldObject === undefined) {
+                            diffs.push({
+                                type: "REMOVE",
+                                path: [path],
+                                oldValue: objValue,
+                                objectId: oldObjectId,
+                            });
+                        }
+                        // This object still exists but at a new index within the new array therefore it was moved.
+                        // At this point we can determine whether a new move is necessary or there is one that will place it at the desired index.
+                        else {
+                            diffs.push({
+                                type: "MOVE",
+                                path: [path],
+                                newIndex: newIndexOfOldObject,
+                                value: objValue,
+                                objectId: oldObjectId,
+                            });
+                            // An object could have been moved AND changed. We need to check for this.
+                            const nestedDiffs = sharedTreeDiff(obj[path], newObj[newIndexOfOldObject], options, options.cyclesFix === true
+                                ? [..._stack, objValue]
+                                : []);
+                            diffs.push(...nestedDiffs.map((difference) => {
+                                difference.path.unshift(path);
+                                return difference;
+                            }));
+                        }
+                    }
+                }
+                else {
+                    const nestedDiffs = sharedTreeDiff(objValue, newObjValue, options, options.cyclesFix === true
+                        ? [..._stack, objValue]
+                        : []);
+                    diffs.push(...nestedDiffs.map((difference) => {
+                        difference.path.unshift(path);
+                        return difference;
+                    }));
+                }
+            }
+        }
+        // 2b. If the given old object key exists in the new object, and the value of said key in both objects is NOT another nested object, we need to check if the values are the same.
+        else if (objValue !== newObjValue &&
+            // treat NaN values as equivalent
+            !(Number.isNaN(objValue) && Number.isNaN(newObjValue)) &&
+            !(areCompatibleObjects &&
+                (Number.isNaN(objValue)
+                    ? // eslint-disable-next-line prefer-template
+                        objValue + "" === newObjValue + ""
+                    : // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        +objValue === +newObjValue))) {
+            diffs.push({
+                path: [path],
+                type: "CHANGE",
+                value: newObjValue,
+                oldValue: objValue,
+                objectId: options.useObjectIds?.idAttributeName === undefined
+                    ? undefined
+                    : newObj[options.useObjectIds.idAttributeName],
+            });
+        }
+    }
+    // 3. Finally, we check for new keys in the new object that did not exist in the old object.
+    // The existence of new keys may signal new values or moved values.
+    const newObjKeys = isTreeMapNode(newObj) ? newObj.keys() : Object.keys(newObj);
+    for (const key of newObjKeys) {
+        const newObjValue = isTreeMapNode(newObj)
+            ? newObj.get(key)
+            : newObj[key];
+        const path = isNewObjArray ? +key : key;
+        const isKeyInOldObject = isTreeMapNode(obj)
+            ? obj.has(key)
+            : Object.keys(obj).includes(key);
+        if (!isKeyInOldObject) {
+            if (options.useObjectIds === undefined) {
+                diffs.push({
+                    type: "CREATE",
+                    path: [path],
+                    value: newObjValue,
+                });
+            }
+            // If we're dealing with an object in an array, we can use the object's id to check if this new index actually
+            // contains a prexisting object that was moved from an old index.
+            else if (isObjArray === true &&
+                isNewObjArray === true &&
+                typeof newObjValue === "object" &&
+                newObjValue !== null) {
+                const objectId = newObjValue[options.useObjectIds.idAttributeName];
+                if (objectId !== undefined && oldObjArrayItemIdsToIndex.has(objectId)) {
+                    // The new root object array contains a new index, however the object that lives at this new index previously existed at an old index.
+                    // Therefore, this object was moved to a new index.
+                    diffs.push({
+                        type: "MOVE",
+                        path: [path],
+                        newIndex: newObjArrayItemIdsToIndex.get(objectId),
+                        value: newObjValue,
+                        objectId,
+                    });
+                    continue;
+                }
+                // If either the object's id attribute does not exist or the original array does not contain an object with the given id
+                // Then we assume this was a newly created object.
+                else {
+                    diffs.push({
+                        type: "CREATE",
+                        path: [path],
+                        value: newObjValue,
+                    });
+                }
+            }
+            // If we're not dealing with an object in an array, we can't use id's to check for a move.
+            // We'll assume that a brand new key and value pair in the new object means that a new value was created.
+            else {
+                diffs.push({
+                    type: "CREATE",
+                    path: [path],
+                    value: newObjValue,
+                });
+            }
+        }
+        else if (options.useObjectIds !== undefined) {
+            // If we're dealing with an object in an array, we can use the object's id to check if this EXISTING index
+            // houses a new object based on a newly encountered id.
+            if (isObjArray === true &&
+                isNewObjArray === true &&
+                typeof newObjValue === "object" &&
+                newObjValue !== null) {
+                const objectId = newObjValue[options.useObjectIds.idAttributeName];
+                // If this object has an id and it does not exist in the old array, then it was created.
+                if (objectId !== undefined && oldObjArrayItemIdsToIndex.has(objectId) === false) {
+                    diffs.push({
+                        type: "CREATE",
+                        path: [path],
+                        value: newObjValue,
+                    });
+                }
+            }
+            else {
+                continue;
+            }
+        }
+    }
+    return diffs;
+}
+/**
+ * Type Guard that determines if a given object is an array of type unknown[] or {@link TreeArrayNode}.
+ */
+function isArrayOrTreeArrayNode(obj) {
+    if (typeof obj === "object" && obj !== null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const maybeNodeKind = Object.getPrototypeOf(obj)?.constructor?.kind;
+        const isTreeArrayNode = maybeNodeKind === NodeKind.Array;
+        return Array.isArray(obj) || isTreeArrayNode;
+    }
+    return false;
+}
+/**
+ * Helper that creates a map of object ids to their index in an array of objects.
+ */
+function createObjectArrayItemIdsToIndexMap(obj, idAttributeName) {
+    const objArrayItemIdsToIndex = new Map();
+    for (let i = 0; i < obj.length; i++) {
+        const objArrayItem = obj[i];
+        if (typeof objArrayItem === "object" && objArrayItem !== null) {
+            const id = objArrayItem[idAttributeName];
+            if (objArrayItemIdsToIndex.has(id)) {
+                throw new TypeError(`Duplicate object id found: ${id}`);
+            }
+            else if (id !== undefined) {
+                objArrayItemIdsToIndex.set(id, i);
+            }
+        }
+    }
+    return objArrayItemIdsToIndex;
+}
+/**
+ * Creates a set of mergeable diffs from a series of diffs produced by {@link sharedTreeDiff}
+ * that are using the object ID strategy. These diffs don't need any modifications to be applied to the old object.
+ *
+ * @alpha
+ */
+export function createMergableIdDiffSeries(oldObject, diffs, idAttributeName) {
+    // the final series of diffs that will be returned.
+    const finalDiffSeries = [];
+    // Diffs that aren't of type 'CHANGE'
+    const nonChangeDiffs = [];
+    for (const diff of diffs) {
+        if (diff.type === "CHANGE") {
+            // Changes must be applied before any other diff, ao so they are ordered first.
+            finalDiffSeries.push({ ...diff });
+        }
+        else {
+            nonChangeDiffs.push({ ...diff });
+        }
+    }
+    // Create sets of array diffs grouped by the array they are applying changes to.
+    const diffsByArrayUuid = new Map();
+    for (const diff of nonChangeDiffs) {
+        if (!isDiffOnArray(diff)) {
+            continue;
+        }
+        const arrayUuid = arrayUuidFromPath(diff.path);
+        if (diffsByArrayUuid.has(arrayUuid) === false) {
+            diffsByArrayUuid.set(arrayUuid, []);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        diffsByArrayUuid.get(arrayUuid).push(diff);
+    }
+    const shiftIndexesFromMove = (diff, targetArray, diffAdjustedObjectIndexes, objectId) => {
+        const sourceIndex = diff.path[diff.path.length - 1];
+        if (diff.newIndex > sourceIndex) {
+            // This move diff shifts objects it moved over to the left.
+            //                                            |----|             |----|
+            // e.g. - shift with no length change: [{1}, {2}, {3}, {4}] -> [{2}, {3}, {1}, {4}]
+            const minIndex = sourceIndex;
+            const maxIndex = diff.newIndex;
+            for (const [id, index] of diffAdjustedObjectIndexes.entries()) {
+                const shouldIndexBeShifted = id !== objectId && index <= maxIndex && index >= minIndex && index - 1 >= 0;
+                if (shouldIndexBeShifted) {
+                    diffAdjustedObjectIndexes.set(id, index - 1);
+                }
+            }
+        }
+        else if (diff.newIndex < sourceIndex) {
+            // This move diff shifts objects it moved over to the right.
+            //                                       |----|                       |----|
+            // e.g. - shift with no length change: [{1}, {2}, {3}, {4}] -> [{3}, {1}, {2}, {4}]
+            const minIndex = diff.newIndex;
+            const maxIndex = sourceIndex;
+            for (const [id, index] of diffAdjustedObjectIndexes.entries()) {
+                const shouldIndexBeShifted = id !== objectId &&
+                    index <= maxIndex &&
+                    index >= minIndex &&
+                    index + 1 <= targetArray.length;
+                if (shouldIndexBeShifted) {
+                    diffAdjustedObjectIndexes.set(id, index + 1);
+                }
+            }
+        }
+    };
+    const shiftIndexesFromRemove = (diff, diffAdjustedObjectIndexes, objectId) => {
+        const removalIndex = diff.path[diff.path.length - 1];
+        for (const [id, index] of diffAdjustedObjectIndexes.entries()) {
+            const shouldIndexBeShifted = id !== objectId && index > removalIndex && index - 1 >= 0;
+            if (shouldIndexBeShifted) {
+                diffAdjustedObjectIndexes.set(id, index - 1);
+            }
+        }
+    };
+    const diffsMarkedForRemoval = new Set();
+    const arrayDiffsMarkedForEndReorder = new Map();
+    for (const [arrayUuid, arrayDiffs] of diffsByArrayUuid.entries()) {
+        // The prior grouping code ensures that each map value will have atleast 1 diff.
+        const targetArray = getTargetObjectFromPath(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        arrayDiffs[0].path, oldObject);
+        const diffAdjustedObjectIndexes = createObjectArrayItemIdsToIndexMap(targetArray, idAttributeName);
+        for (const diff of arrayDiffs) {
+            if (diff.type === "MOVE") {
+                const objectId = diff.value[idAttributeName];
+                const sourceIndex = diff.path[diff.path.length - 1];
+                // 1. Prior moves may render the next move redundant.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const currentAdjustedIndex = diffAdjustedObjectIndexes.get(objectId);
+                if (currentAdjustedIndex === diff.newIndex) {
+                    diffsMarkedForRemoval.add(diff);
+                    continue;
+                }
+                if (currentAdjustedIndex !== sourceIndex) {
+                    // A Prior Remove or Move Diff moved the object to a new index, so update the diff source index to point to the new index.
+                    diff.path[diff.path.length - 1] = currentAdjustedIndex;
+                }
+                // Handle index shifts
+                diffAdjustedObjectIndexes.set(objectId, diff.newIndex);
+                // edge case: this MOVE should be applied after some series of creates that we haven't seen.
+                if (diff.newIndex > targetArray.length - 1) {
+                    // It also wont shift any indexes since its moved to the total end of the array,
+                    // after creations that produce the necessary indexes.
+                    if (arrayDiffsMarkedForEndReorder.has(arrayUuid) === false) {
+                        arrayDiffsMarkedForEndReorder.set(arrayUuid, []);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    arrayDiffsMarkedForEndReorder.get(arrayUuid).push(diff);
+                }
+                else {
+                    shiftIndexesFromMove(diff, targetArray, diffAdjustedObjectIndexes, objectId);
+                }
+            }
+            if (diff.type === "REMOVE") {
+                const objectId = diff.oldValue[idAttributeName];
+                const targetIndex = diff.path[diff.path.length - 1];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const currentDiffAdjustedIndex = diffAdjustedObjectIndexes.get(objectId);
+                if (targetIndex !== diffAdjustedObjectIndexes.get(objectId)) {
+                    // A Prior Remove or Move Diff moved the object to a new index, so update the diff source index to point to the new index.
+                    diff.path[diff.path.length - 1] = currentDiffAdjustedIndex;
+                }
+                shiftIndexesFromRemove(diff, diffAdjustedObjectIndexes, objectId);
+            }
+            // Ignoring 'CREATE' for now.
+        }
+    }
+    for (let i = 0; i < nonChangeDiffs.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const diff = nonChangeDiffs[i];
+        if (diffsMarkedForRemoval.has(diff)) {
+            continue;
+        }
+        const isLastDiffInArraySeries = (currentIndex) => {
+            if (currentIndex === nonChangeDiffs.length - 1) {
+                return true;
+            }
+            const nextIndex = currentIndex + 1;
+            if (nextIndex <= nonChangeDiffs.length - 1) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const diffAfter = nonChangeDiffs[nextIndex];
+                if (diffsMarkedForRemoval.has(diffAfter)) {
+                    return isLastDiffInArraySeries(nextIndex + 1);
+                }
+                const arrayUuidAfter = arrayUuidFromPath(diffAfter.path);
+                const arrayUuid = arrayUuidFromPath(diff.path);
+                if (arrayUuidAfter === arrayUuid) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        if (isDiffOnArray(diff)) {
+            const arrayUuid = arrayUuidFromPath(diff.path);
+            const endReorderDiffs = arrayDiffsMarkedForEndReorder.get(arrayUuid);
+            const isDiffMarkedForReorder = endReorderDiffs?.includes(diff) ?? false;
+            if (isDiffMarkedForReorder === false) {
+                finalDiffSeries.push(diff);
+            }
+            if (isLastDiffInArraySeries(i) && endReorderDiffs !== undefined) {
+                finalDiffSeries.push(...endReorderDiffs);
+            }
+            continue;
+        }
+        finalDiffSeries.push(diff);
+    }
+    return finalDiffSeries;
+}
+/**
+ * Creates a set of mergeable diffs from a series of diffs produced by {@link sharedTreeDiff}
+ * that AREN'T using the object ID strategy. These diffs don't need any modifications to be applied to the old object.
+ *
+ * @alpha
+ */
+export function createMergableDiffSeries(diffs) {
+    // the final series of diffs that will be returned.
+    const finalDiffSeries = [];
+    // Diffs that aren't of type 'CHANGE'
+    const nonChangeDiffs = [];
+    for (const diff of diffs) {
+        if (diff.type === "CHANGE") {
+            // Changes must be applied before any other diff, ao so they are ordered first.
+            finalDiffSeries.push({ ...diff });
+        }
+        else {
+            nonChangeDiffs.push({ ...diff });
+        }
+    }
+    finalDiffSeries.push(...nonChangeDiffs);
+    return finalDiffSeries;
+}
+/**
+ * Creates a UUID for the target array from a {@link Difference}'s ${@link ObjectPath}
+ */
+function arrayUuidFromPath(path) {
+    return path.length === 1 ? "" : path.slice(0, -1).join("");
+}
+/**
+ * Determines if a given difference is on an array.
+ */
+export function isDiffOnArray(diff) {
+    return typeof diff.path[diff.path.length - 1] === "number";
+}
+/**
+ * Returns the target object that the given diff should be applied to.
+ */
+function getTargetObjectFromPath(path, object) {
+    let targetObject = object;
+    if (path.length > 1) {
+        targetObject = sharedTreeTraverse(object, path.slice(0, -1));
+    }
+    return targetObject;
+}
+//# sourceMappingURL=sharedTreeDiff.js.map

package/lib/implicit-strategy/sharedTreeDiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedTreeDiff.js","sourceRoot":"","sources":["../../src/implicit-strategy/sharedTreeDiff.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 { type TreeArrayNode, NodeKind } from \"@fluidframework/tree\";\n\nimport { isTreeMapNode, sharedTreeTraverse } from \"./utils.js\";\n\n/**\n * Represents a path through a tree of objects.\n * number values represent array indices whereas string values represent object keys.\n *\n * @alpha\n */\nexport type ObjectPath = (string | number)[];\n\n/**\n * Represents a create operation between two branches of a tree.\n * Meaning that an attribute (a shared tree node) was identified as being created.\n *\n * @alpha\n */\nexport interface DifferenceCreate {\n\ttype: \"CREATE\";\n\tpath: ObjectPath;\n\tvalue: unknown;\n}\n\n/**\n * Represents a remove operation between two branches of a tree.\n * Meaning that an attribute (a shared tree node) was identified as being deleted.\n * When using object ids, removes are idenitified by an object with a given id no longer existing.\n *\n * @alpha\n */\nexport interface DifferenceRemove {\n\ttype: \"REMOVE\";\n\tpath: ObjectPath;\n\toldValue: unknown;\n\tobjectId?: string | number | undefined;\n}\n\n/**\n * Represents a change operation between two branches of a tree.\n * Meaning that an attribute (a shared tree node) was identified as being changed from one value to another.\n *\n * @alpha\n */\nexport interface DifferenceChange {\n\ttype: \"CHANGE\";\n\tpath: ObjectPath;\n\tvalue: unknown;\n\toldValue: unknown;\n\tobjectId?: string | number | undefined;\n}\n\n/**\n * Represents a move operation between two branches of a tree.\n * Meaning that an object (shared tree node) was identified as being moved from one index to another based on its unique id.\n *\n * @alpha\n */\nexport interface DifferenceMove {\n\ttype: \"MOVE\";\n\tpath: ObjectPath;\n\tnewIndex: number;\n\tvalue: unknown;\n\tobjectId?: string | number | undefined;\n}\n\n/**\n * Union for all possible difference types.\n *\n * @alpha\n */\nexport type Difference =\n\t| DifferenceCreate\n\t| DifferenceRemove\n\t| DifferenceChange\n\t| DifferenceMove;\n\n/**\n * Options for tree diffing.\n * @alpha\n */\nexport interface Options {\n\tcyclesFix: boolean;\n\tuseObjectIds?:\n\t\t| {\n\t\t\t\tidAttributeName: string;\n\t\t  }\n\t\t| undefined;\n}\n\nconst richTypes = { Date: true, RegExp: true, String: true, Number: true };\n\n/**\n * By default, Object Diff supports cyclical references, but if you are sure that the object has no cycles like parsed JSON\n * you can disable cycles by setting the cyclesFix option to false\n */\nconst DEFAULT_OPTIONS: Options = { cyclesFix: true };\n\n/**\n * Compares two objects and returns an array of differences between them.\n *\n * @alpha\n */\nexport function sharedTreeDiff(\n\tobj: Record<string, unknown> | unknown[],\n\tnewObj: Record<string, unknown> | unknown[],\n\toptions: Options = DEFAULT_OPTIONS,\n\t_stack: (Record<string, unknown> | unknown[])[] = [],\n): Difference[] {\n\tconst diffs: Difference[] = [];\n\tconst isObjArray = isArrayOrTreeArrayNode(obj);\n\tconst isNewObjArray = isArrayOrTreeArrayNode(newObj);\n\n\t// If useObjectIds is set, we'll create a map of object ids to their index in the array.\n\tconst oldObjArrayItemIdsToIndex =\n\t\tisObjArray === false || options.useObjectIds === undefined\n\t\t\t? new Map<string | number, number>()\n\t\t\t: createObjectArrayItemIdsToIndexMap(obj, options.useObjectIds.idAttributeName);\n\n\tconst newObjArrayItemIdsToIndex =\n\t\tisNewObjArray === false || options.useObjectIds === undefined\n\t\t\t? new Map<string | number, number>()\n\t\t\t: createObjectArrayItemIdsToIndexMap(newObj, options.useObjectIds.idAttributeName);\n\n\tconst objectKeys = isTreeMapNode(obj) ? obj.keys() : Object.keys(obj);\n\t// We compare existence and values of all attributes within the old against new object, looking for removals or changes.\n\tfor (const key of objectKeys) {\n\t\tconst objValue: unknown = isTreeMapNode(obj) ? obj.get(key as string) : obj[key];\n\t\tconst path = isObjArray ? +key : key;\n\t\t// 1. First, check if the key within the old object, exists within the new object. If it doesn't exist this would be an attribute removal.\n\t\tif (!(key in newObj)) {\n\t\t\tif (options.useObjectIds === undefined) {\n\t\t\t\tdiffs.push({\n\t\t\t\t\ttype: \"REMOVE\",\n\t\t\t\t\tpath: [path],\n\t\t\t\t\tobjectId: undefined,\n\t\t\t\t\toldValue: objValue,\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// If we're dealing with an object in an array, we can use the object's id to check if it was moved to a new index.\n\t\t\telse if (\n\t\t\t\tisNewObjArray === true &&\n\t\t\t\tisObjArray &&\n\t\t\t\ttypeof objValue === \"object\" &&\n\t\t\t\tobjValue !== null\n\t\t\t) {\n\t\t\t\tconst objectId = objValue[options.useObjectIds.idAttributeName] as\n\t\t\t\t\t| string\n\t\t\t\t\t| number\n\t\t\t\t\t| undefined;\n\t\t\t\tif (objectId !== undefined && newObjArrayItemIdsToIndex.has(objectId)) {\n\t\t\t\t\t// The index no longer exists in the new root object array, however the object that lived at this index actually still exists at a new index.\n\t\t\t\t\t// Therefore, this node was moved to a new index.\n\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\ttype: \"MOVE\",\n\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\tnewIndex: newObjArrayItemIdsToIndex.get(objectId) as number,\n\t\t\t\t\t\tvalue: objValue,\n\t\t\t\t\t\tobjectId,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// The object with the given id cannot be found within the new array, therefore it was removed.\n\t\t\t\telse {\n\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\ttype: \"REMOVE\",\n\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\tobjectId,\n\t\t\t\t\t\toldValue: objValue,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// If we're not dealing with an object in an array, we can't use id's to check for a move.\n\t\t\t// We'll assume that a missing key in the new object means that the cooresponding value was removed.\n\t\t\telse {\n\t\t\t\tdiffs.push({\n\t\t\t\t\ttype: \"REMOVE\",\n\t\t\t\t\tpath: [path],\n\t\t\t\t\tobjectId: undefined,\n\t\t\t\t\toldValue: objValue,\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\n\t\tconst newObjValue: unknown = newObj[key];\n\t\tconst areCompatibleObjects =\n\t\t\ttypeof objValue === \"object\" &&\n\t\t\ttypeof newObjValue === \"object\" &&\n\t\t\tisArrayOrTreeArrayNode(objValue) === isArrayOrTreeArrayNode(newObjValue);\n\n\t\t// 2a. If the given old object key exists in the new object, and the value of said key in both objects is ANOTHER nested object, we need to run a recursive diff check on them.\n\t\tif (\n\t\t\tobjValue !== null &&\n\t\t\tnewObjValue !== null &&\n\t\t\tareCompatibleObjects &&\n\t\t\t// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions, @typescript-eslint/no-unsafe-member-access\n\t\t\t!richTypes[Object.getPrototypeOf(objValue)?.constructor?.name] &&\n\t\t\t(!options.cyclesFix || !_stack.includes(objValue as Record<string, unknown>))\n\t\t) {\n\t\t\tif (options.useObjectIds === undefined) {\n\t\t\t\tconst nestedDiffs = sharedTreeDiff(\n\t\t\t\t\tobjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\tnewObjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\toptions,\n\t\t\t\t\toptions.cyclesFix === true\n\t\t\t\t\t\t? [..._stack, objValue as Record<string, unknown> | unknown[]]\n\t\t\t\t\t\t: [],\n\t\t\t\t);\n\t\t\t\t// eslint-disable-next-line prefer-spread\n\t\t\t\tdiffs.push.apply(\n\t\t\t\t\tdiffs,\n\t\t\t\t\tnestedDiffs.map((difference) => {\n\t\t\t\t\t\tdifference.path.unshift(path);\n\t\t\t\t\t\treturn difference;\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t}\n\t\t\t// Use Object Id strategy to determine if the objects should be compared for changes\n\t\t\telse {\n\t\t\t\tconst oldObjectId = (objValue as Record<string, unknown>)[\n\t\t\t\t\toptions.useObjectIds.idAttributeName\n\t\t\t\t] as string | number | undefined;\n\t\t\t\tconst newObjectId = (newObjValue as Record<string, unknown>)[\n\t\t\t\t\toptions.useObjectIds.idAttributeName\n\t\t\t\t] as string | number | undefined;\n\n\t\t\t\tif (oldObjectId !== undefined && newObjectId !== undefined) {\n\t\t\t\t\t// 2a.1 if the object id's are the same, we can continue a comparison between the two objects.\n\t\t\t\t\tif (oldObjectId === newObjectId) {\n\t\t\t\t\t\tconst nestedDiffs = sharedTreeDiff(\n\t\t\t\t\t\t\tobjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\t\t\tnewObjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\t\t\toptions,\n\t\t\t\t\t\t\toptions.cyclesFix === true\n\t\t\t\t\t\t\t\t? [..._stack, objValue as Record<string, unknown> | unknown[]]\n\t\t\t\t\t\t\t\t: [],\n\t\t\t\t\t\t);\n\t\t\t\t\t\tdiffs.push(\n\t\t\t\t\t\t\t...nestedDiffs.map((difference) => {\n\t\t\t\t\t\t\t\tdifference.path.unshift(path);\n\t\t\t\t\t\t\t\treturn difference;\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\t// 2a.2 The object id's are different, their attributes cannot be compared.\n\t\t\t\t\t// We need to find the new index of the object, if it exists in the new array and do a diff comparison.\n\t\t\t\t\telse {\n\t\t\t\t\t\tconst newIndexOfOldObject = newObjArrayItemIdsToIndex.get(oldObjectId);\n\t\t\t\t\t\t// The object no longer exists in the new array, therefore it was removed.\n\t\t\t\t\t\tif (newIndexOfOldObject === undefined) {\n\t\t\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\t\t\ttype: \"REMOVE\",\n\t\t\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\t\t\toldValue: objValue,\n\t\t\t\t\t\t\t\tobjectId: oldObjectId,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// This object still exists but at a new index within the new array therefore it was moved.\n\t\t\t\t\t\t// At this point we can determine whether a new move is necessary or there is one that will place it at the desired index.\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\t\t\ttype: \"MOVE\",\n\t\t\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\t\t\tnewIndex: newIndexOfOldObject,\n\t\t\t\t\t\t\t\tvalue: objValue,\n\t\t\t\t\t\t\t\tobjectId: oldObjectId,\n\t\t\t\t\t\t\t});\n\n\t\t\t\t\t\t\t// An object could have been moved AND changed. We need to check for this.\n\t\t\t\t\t\t\tconst nestedDiffs = sharedTreeDiff(\n\t\t\t\t\t\t\t\tobj[path] as Record<string, unknown> | unknown[],\n\t\t\t\t\t\t\t\tnewObj[newIndexOfOldObject] as Record<string, unknown> | unknown[],\n\t\t\t\t\t\t\t\toptions,\n\t\t\t\t\t\t\t\toptions.cyclesFix === true\n\t\t\t\t\t\t\t\t\t? [..._stack, objValue as Record<string, unknown> | unknown[]]\n\t\t\t\t\t\t\t\t\t: [],\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tdiffs.push(\n\t\t\t\t\t\t\t\t...nestedDiffs.map((difference) => {\n\t\t\t\t\t\t\t\t\tdifference.path.unshift(path);\n\t\t\t\t\t\t\t\t\treturn difference;\n\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst nestedDiffs = sharedTreeDiff(\n\t\t\t\t\t\tobjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\t\tnewObjValue as Record<string, unknown> | unknown[],\n\t\t\t\t\t\toptions,\n\t\t\t\t\t\toptions.cyclesFix === true\n\t\t\t\t\t\t\t? [..._stack, objValue as Record<string, unknown> | unknown[]]\n\t\t\t\t\t\t\t: [],\n\t\t\t\t\t);\n\t\t\t\t\tdiffs.push(\n\t\t\t\t\t\t...nestedDiffs.map((difference) => {\n\t\t\t\t\t\t\tdifference.path.unshift(path);\n\t\t\t\t\t\t\treturn difference;\n\t\t\t\t\t\t}),\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// 2b. If the given old object key exists in the new object, and the value of said key in both objects is NOT another nested object, we need to check if the values are the same.\n\t\telse if (\n\t\t\tobjValue !== newObjValue &&\n\t\t\t// treat NaN values as equivalent\n\t\t\t!(Number.isNaN(objValue) && Number.isNaN(newObjValue)) &&\n\t\t\t!(\n\t\t\t\tareCompatibleObjects &&\n\t\t\t\t(Number.isNaN(objValue)\n\t\t\t\t\t? // eslint-disable-next-line prefer-template\n\t\t\t\t\t\tobjValue + \"\" === newObjValue + \"\"\n\t\t\t\t\t: // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t+objValue === +newObjValue)\n\t\t\t)\n\t\t) {\n\t\t\tdiffs.push({\n\t\t\t\tpath: [path],\n\t\t\t\ttype: \"CHANGE\",\n\t\t\t\tvalue: newObjValue,\n\t\t\t\toldValue: objValue,\n\t\t\t\tobjectId:\n\t\t\t\t\toptions.useObjectIds?.idAttributeName === undefined\n\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t: (newObj[options.useObjectIds.idAttributeName] as string | number | undefined),\n\t\t\t});\n\t\t}\n\t}\n\n\t// 3. Finally, we check for new keys in the new object that did not exist in the old object.\n\t// The existence of new keys may signal new values or moved values.\n\tconst newObjKeys = isTreeMapNode(newObj) ? newObj.keys() : Object.keys(newObj);\n\tfor (const key of newObjKeys) {\n\t\tconst newObjValue: unknown = isTreeMapNode(newObj)\n\t\t\t? newObj.get(key as string)\n\t\t\t: newObj[key];\n\t\tconst path = isNewObjArray ? +key : key;\n\n\t\tconst isKeyInOldObject = isTreeMapNode(obj)\n\t\t\t? obj.has(key as string)\n\t\t\t: Object.keys(obj).includes(key as string);\n\t\tif (!isKeyInOldObject) {\n\t\t\tif (options.useObjectIds === undefined) {\n\t\t\t\tdiffs.push({\n\t\t\t\t\ttype: \"CREATE\",\n\t\t\t\t\tpath: [path],\n\t\t\t\t\tvalue: newObjValue,\n\t\t\t\t});\n\t\t\t}\n\t\t\t// If we're dealing with an object in an array, we can use the object's id to check if this new index actually\n\t\t\t// contains a prexisting object that was moved from an old index.\n\t\t\telse if (\n\t\t\t\tisObjArray === true &&\n\t\t\t\tisNewObjArray === true &&\n\t\t\t\ttypeof newObjValue === \"object\" &&\n\t\t\t\tnewObjValue !== null\n\t\t\t) {\n\t\t\t\tconst objectId = newObjValue[options.useObjectIds.idAttributeName] as\n\t\t\t\t\t| string\n\t\t\t\t\t| number\n\t\t\t\t\t| undefined;\n\t\t\t\tif (objectId !== undefined && oldObjArrayItemIdsToIndex.has(objectId)) {\n\t\t\t\t\t// The new root object array contains a new index, however the object that lives at this new index previously existed at an old index.\n\t\t\t\t\t// Therefore, this object was moved to a new index.\n\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\ttype: \"MOVE\",\n\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\tnewIndex: newObjArrayItemIdsToIndex.get(objectId) as number,\n\t\t\t\t\t\tvalue: newObjValue,\n\t\t\t\t\t\tobjectId,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// If either the object's id attribute does not exist or the original array does not contain an object with the given id\n\t\t\t\t// Then we assume this was a newly created object.\n\t\t\t\telse {\n\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\ttype: \"CREATE\",\n\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\tvalue: newObjValue,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// If we're not dealing with an object in an array, we can't use id's to check for a move.\n\t\t\t// We'll assume that a brand new key and value pair in the new object means that a new value was created.\n\t\t\telse {\n\t\t\t\tdiffs.push({\n\t\t\t\t\ttype: \"CREATE\",\n\t\t\t\t\tpath: [path],\n\t\t\t\t\tvalue: newObjValue,\n\t\t\t\t});\n\t\t\t}\n\t\t} else if (options.useObjectIds !== undefined) {\n\t\t\t// If we're dealing with an object in an array, we can use the object's id to check if this EXISTING index\n\t\t\t// houses a new object based on a newly encountered id.\n\t\t\tif (\n\t\t\t\tisObjArray === true &&\n\t\t\t\tisNewObjArray === true &&\n\t\t\t\ttypeof newObjValue === \"object\" &&\n\t\t\t\tnewObjValue !== null\n\t\t\t) {\n\t\t\t\tconst objectId = newObjValue[options.useObjectIds.idAttributeName] as\n\t\t\t\t\t| string\n\t\t\t\t\t| number\n\t\t\t\t\t| undefined;\n\t\t\t\t// If this object has an id and it does not exist in the old array, then it was created.\n\t\t\t\tif (objectId !== undefined && oldObjArrayItemIdsToIndex.has(objectId) === false) {\n\t\t\t\t\tdiffs.push({\n\t\t\t\t\t\ttype: \"CREATE\",\n\t\t\t\t\t\tpath: [path],\n\t\t\t\t\t\tvalue: newObjValue,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t}\n\treturn diffs;\n}\n\n/**\n * Type Guard that determines if a given object is an array of type unknown[] or {@link TreeArrayNode}.\n */\nfunction isArrayOrTreeArrayNode(obj: unknown): obj is unknown[] | TreeArrayNode {\n\tif (typeof obj === \"object\" && obj !== null) {\n\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\t\tconst maybeNodeKind: unknown = Object.getPrototypeOf(obj)?.constructor?.kind;\n\t\tconst isTreeArrayNode = maybeNodeKind === NodeKind.Array;\n\t\treturn Array.isArray(obj) || isTreeArrayNode;\n\t}\n\treturn false;\n}\n\n/**\n * Helper that creates a map of object ids to their index in an array of objects.\n */\nfunction createObjectArrayItemIdsToIndexMap(\n\tobj: unknown[],\n\tidAttributeName: string | number,\n): Map<string | number, number> {\n\tconst objArrayItemIdsToIndex = new Map<string | number, number>();\n\tfor (let i = 0; i < obj.length; i++) {\n\t\tconst objArrayItem = obj[i];\n\t\tif (typeof objArrayItem === \"object\" && objArrayItem !== null) {\n\t\t\tconst id = (objArrayItem as Record<string, unknown>)[idAttributeName] as string | number;\n\t\t\tif (objArrayItemIdsToIndex.has(id)) {\n\t\t\t\tthrow new TypeError(`Duplicate object id found: ${id}`);\n\t\t\t} else if (id !== undefined) {\n\t\t\t\tobjArrayItemIdsToIndex.set(id, i);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn objArrayItemIdsToIndex;\n}\n\n/**\n * Creates a set of mergeable diffs from a series of diffs produced by {@link sharedTreeDiff}\n * that are using the object ID strategy. These diffs don't need any modifications to be applied to the old object.\n *\n * @alpha\n */\nexport function createMergableIdDiffSeries(\n\toldObject: unknown,\n\tdiffs: Difference[],\n\tidAttributeName: string | number,\n): Difference[] {\n\t// the final series of diffs that will be returned.\n\tconst finalDiffSeries: Difference[] = [];\n\t// Diffs that aren't of type 'CHANGE'\n\tconst nonChangeDiffs: Difference[] = [];\n\n\tfor (const diff of diffs) {\n\t\tif (diff.type === \"CHANGE\") {\n\t\t\t// Changes must be applied before any other diff, ao so they are ordered first.\n\t\t\tfinalDiffSeries.push({ ...diff });\n\t\t} else {\n\t\t\tnonChangeDiffs.push({ ...diff });\n\t\t}\n\t}\n\n\t// Create sets of array diffs grouped by the array they are applying changes to.\n\tconst diffsByArrayUuid = new Map<string, Difference[]>();\n\tfor (const diff of nonChangeDiffs) {\n\t\tif (!isDiffOnArray(diff)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst arrayUuid = arrayUuidFromPath(diff.path);\n\n\t\tif (diffsByArrayUuid.has(arrayUuid) === false) {\n\t\t\tdiffsByArrayUuid.set(arrayUuid, []);\n\t\t}\n\n\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\tdiffsByArrayUuid.get(arrayUuid)!.push(diff);\n\t}\n\n\tconst shiftIndexesFromMove = (\n\t\tdiff: DifferenceMove,\n\t\ttargetArray: unknown[],\n\t\tdiffAdjustedObjectIndexes: Map<string | number, number>,\n\t\tobjectId: string | number,\n\t): void => {\n\t\tconst sourceIndex = diff.path[diff.path.length - 1] as number;\n\n\t\tif (diff.newIndex > sourceIndex) {\n\t\t\t// This move diff shifts objects it moved over to the left.\n\t\t\t//                                            |----|             |----|\n\t\t\t// e.g. - shift with no length change: [{1}, {2}, {3}, {4}] -> [{2}, {3}, {1}, {4}]\n\t\t\tconst minIndex = sourceIndex;\n\t\t\tconst maxIndex = diff.newIndex;\n\t\t\tfor (const [id, index] of diffAdjustedObjectIndexes.entries()) {\n\t\t\t\tconst shouldIndexBeShifted =\n\t\t\t\t\tid !== objectId && index <= maxIndex && index >= minIndex && index - 1 >= 0;\n\t\t\t\tif (shouldIndexBeShifted) {\n\t\t\t\t\tdiffAdjustedObjectIndexes.set(id, index - 1);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (diff.newIndex < sourceIndex) {\n\t\t\t// This move diff shifts objects it moved over to the right.\n\t\t\t//                                       |----|                       |----|\n\t\t\t// e.g. - shift with no length change: [{1}, {2}, {3}, {4}] -> [{3}, {1}, {2}, {4}]\n\t\t\tconst minIndex = diff.newIndex;\n\t\t\tconst maxIndex = sourceIndex;\n\t\t\tfor (const [id, index] of diffAdjustedObjectIndexes.entries()) {\n\t\t\t\tconst shouldIndexBeShifted =\n\t\t\t\t\tid !== objectId &&\n\t\t\t\t\tindex <= maxIndex &&\n\t\t\t\t\tindex >= minIndex &&\n\t\t\t\t\tindex + 1 <= targetArray.length;\n\t\t\t\tif (shouldIndexBeShifted) {\n\t\t\t\t\tdiffAdjustedObjectIndexes.set(id, index + 1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\tconst shiftIndexesFromRemove = (\n\t\tdiff: DifferenceRemove,\n\t\tdiffAdjustedObjectIndexes: Map<string | number, number>,\n\t\tobjectId: string | number,\n\t): void => {\n\t\tconst removalIndex = diff.path[diff.path.length - 1] as number;\n\t\tfor (const [id, index] of diffAdjustedObjectIndexes.entries()) {\n\t\t\tconst shouldIndexBeShifted = id !== objectId && index > removalIndex && index - 1 >= 0;\n\t\t\tif (shouldIndexBeShifted) {\n\t\t\t\tdiffAdjustedObjectIndexes.set(id, index - 1);\n\t\t\t}\n\t\t}\n\t};\n\n\tconst diffsMarkedForRemoval = new Set<Difference>();\n\tconst arrayDiffsMarkedForEndReorder = new Map<string, Difference[]>();\n\n\tfor (const [arrayUuid, arrayDiffs] of diffsByArrayUuid.entries()) {\n\t\t// The prior grouping code ensures that each map value will have atleast 1 diff.\n\t\tconst targetArray = getTargetObjectFromPath(\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\tarrayDiffs[0]!.path,\n\t\t\toldObject as TreeArrayNode,\n\t\t) as unknown[];\n\t\tconst diffAdjustedObjectIndexes: Map<string | number, number> =\n\t\t\tcreateObjectArrayItemIdsToIndexMap(targetArray, idAttributeName);\n\n\t\tfor (const diff of arrayDiffs) {\n\t\t\tif (diff.type === \"MOVE\") {\n\t\t\t\tconst objectId = (diff.value as Record<string, unknown>)[idAttributeName] as\n\t\t\t\t\t| string\n\t\t\t\t\t| number;\n\t\t\t\tconst sourceIndex = diff.path[diff.path.length - 1] as number;\n\n\t\t\t\t// 1. Prior moves may render the next move redundant.\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\t\tconst currentAdjustedIndex = diffAdjustedObjectIndexes.get(objectId)!;\n\t\t\t\tif (currentAdjustedIndex === diff.newIndex) {\n\t\t\t\t\tdiffsMarkedForRemoval.add(diff);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (currentAdjustedIndex !== sourceIndex) {\n\t\t\t\t\t// A Prior Remove or Move Diff moved the object to a new index, so update the diff source index to point to the new index.\n\t\t\t\t\tdiff.path[diff.path.length - 1] = currentAdjustedIndex;\n\t\t\t\t}\n\n\t\t\t\t// Handle index shifts\n\t\t\t\tdiffAdjustedObjectIndexes.set(objectId, diff.newIndex);\n\n\t\t\t\t// edge case: this MOVE should be applied after some series of creates that we haven't seen.\n\t\t\t\tif (diff.newIndex > targetArray.length - 1) {\n\t\t\t\t\t// It also wont shift any indexes since its moved to the total end of the array,\n\t\t\t\t\t// after creations that produce the necessary indexes.\n\t\t\t\t\tif (arrayDiffsMarkedForEndReorder.has(arrayUuid) === false) {\n\t\t\t\t\t\tarrayDiffsMarkedForEndReorder.set(arrayUuid, []);\n\t\t\t\t\t}\n\t\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\t\t\tarrayDiffsMarkedForEndReorder.get(arrayUuid)!.push(diff);\n\t\t\t\t} else {\n\t\t\t\t\tshiftIndexesFromMove(diff, targetArray, diffAdjustedObjectIndexes, objectId);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (diff.type === \"REMOVE\") {\n\t\t\t\tconst objectId = (diff.oldValue as Record<string, unknown>)[idAttributeName] as\n\t\t\t\t\t| string\n\t\t\t\t\t| number;\n\t\t\t\tconst targetIndex = diff.path[diff.path.length - 1] as number;\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\t\tconst currentDiffAdjustedIndex = diffAdjustedObjectIndexes.get(objectId)!;\n\t\t\t\tif (targetIndex !== diffAdjustedObjectIndexes.get(objectId)) {\n\t\t\t\t\t// A Prior Remove or Move Diff moved the object to a new index, so update the diff source index to point to the new index.\n\t\t\t\t\tdiff.path[diff.path.length - 1] = currentDiffAdjustedIndex;\n\t\t\t\t}\n\n\t\t\t\tshiftIndexesFromRemove(diff, diffAdjustedObjectIndexes, objectId);\n\t\t\t}\n\n\t\t\t// Ignoring 'CREATE' for now.\n\t\t}\n\t}\n\n\tfor (let i = 0; i < nonChangeDiffs.length; i++) {\n\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\tconst diff = nonChangeDiffs[i]!;\n\n\t\tif (diffsMarkedForRemoval.has(diff)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst isLastDiffInArraySeries = (currentIndex: number): boolean => {\n\t\t\tif (currentIndex === nonChangeDiffs.length - 1) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tconst nextIndex = currentIndex + 1;\n\t\t\tif (nextIndex <= nonChangeDiffs.length - 1) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\t\tconst diffAfter = nonChangeDiffs[nextIndex]!;\n\n\t\t\t\tif (diffsMarkedForRemoval.has(diffAfter)) {\n\t\t\t\t\treturn isLastDiffInArraySeries(nextIndex + 1);\n\t\t\t\t}\n\n\t\t\t\tconst arrayUuidAfter = arrayUuidFromPath(diffAfter.path);\n\t\t\t\tconst arrayUuid = arrayUuidFromPath(diff.path);\n\t\t\t\tif (arrayUuidAfter === arrayUuid) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t};\n\n\t\tif (isDiffOnArray(diff)) {\n\t\t\tconst arrayUuid = arrayUuidFromPath(diff.path);\n\t\t\tconst endReorderDiffs = arrayDiffsMarkedForEndReorder.get(arrayUuid);\n\t\t\tconst isDiffMarkedForReorder = endReorderDiffs?.includes(diff) ?? false;\n\n\t\t\tif (isDiffMarkedForReorder === false) {\n\t\t\t\tfinalDiffSeries.push(diff);\n\t\t\t}\n\n\t\t\tif (isLastDiffInArraySeries(i) && endReorderDiffs !== undefined) {\n\t\t\t\tfinalDiffSeries.push(...endReorderDiffs);\n\t\t\t}\n\n\t\t\tcontinue;\n\t\t}\n\n\t\tfinalDiffSeries.push(diff);\n\t}\n\n\treturn finalDiffSeries;\n}\n\n/**\n * Creates a set of mergeable diffs from a series of diffs produced by {@link sharedTreeDiff}\n * that AREN'T using the object ID strategy. These diffs don't need any modifications to be applied to the old object.\n *\n * @alpha\n */\nexport function createMergableDiffSeries(diffs: Difference[]): Difference[] {\n\t// the final series of diffs that will be returned.\n\tconst finalDiffSeries: Difference[] = [];\n\t// Diffs that aren't of type 'CHANGE'\n\tconst nonChangeDiffs: Difference[] = [];\n\n\tfor (const diff of diffs) {\n\t\tif (diff.type === \"CHANGE\") {\n\t\t\t// Changes must be applied before any other diff, ao so they are ordered first.\n\t\t\tfinalDiffSeries.push({ ...diff });\n\t\t} else {\n\t\t\tnonChangeDiffs.push({ ...diff });\n\t\t}\n\t}\n\n\tfinalDiffSeries.push(...nonChangeDiffs);\n\n\treturn finalDiffSeries;\n}\n\n/**\n * Creates a UUID for the target array from a {@link Difference}'s ${@link ObjectPath}\n */\nfunction arrayUuidFromPath(path: ObjectPath): string {\n\treturn path.length === 1 ? \"\" : path.slice(0, -1).join(\"\");\n}\n\n/**\n * Determines if a given difference is on an array.\n */\nexport function isDiffOnArray(diff: Difference): boolean {\n\treturn typeof diff.path[diff.path.length - 1] === \"number\";\n}\n\n/**\n * Returns the target object that the given diff should be applied to.\n */\nfunction getTargetObjectFromPath(\n\tpath: ObjectPath,\n\tobject: Record<string, unknown> | TreeArrayNode,\n): unknown {\n\tlet targetObject: unknown = object;\n\tif (path.length > 1) {\n\t\ttargetObject = sharedTreeTraverse(object, path.slice(0, -1));\n\t}\n\treturn targetObject;\n}\n"]}

package/lib/implicit-strategy/utils.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type TreeMapNode, type TreeArrayNode } from "@fluidframework/tree";
+import type { ObjectPath } from "./sharedTreeDiff.js";
+/**
+ * Checks if the given object is an {@link TreeMapNode}.
+ */
+export declare function isTreeMapNode(obj: unknown): obj is TreeMapNode;
+/**
+ * Checks if the given object is an {@link TreeArrayNode}.
+ */
+export declare function isTreeArrayNode(obj: unknown): obj is TreeArrayNode;
+/**
+ * Traverses the provided {@link ObjectPath} on the provided Shared Tree or JSON object and returns the value at the end of the path.
+ *
+ * @alpha
+ */
+export declare function sharedTreeTraverse<T = unknown>(jsonObject: TreeMapNode | TreeArrayNode | Record<string, unknown>, path: ObjectPath): T | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/lib/implicit-strategy/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/implicit-strategy/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAY,MAAM,sBAAsB,CAAC;AAEtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAO9D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,aAAa,CAOlE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,OAAO,EAC7C,UAAU,EAAE,WAAW,GAAG,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,IAAI,EAAE,UAAU,GACd,CAAC,GAAG,SAAS,CAYf"}