@verdant-web/common 1.11.0 → 1.12.0

package/dist/cjs/operation.js

@@ -1,533 +1,533 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.substituteFirstLevelObjectsWithRefs = exports.substituteRefsWithObjects = exports.applyOperations = exports.applyPatch = exports.groupBaselinesByRootOid = exports.groupPatchesByRootOid = exports.groupPatchesByIdentifier = exports.shallowInitialToPatches = exports.initialToPatches = exports.shallowDiffToPatches = exports.diffToPatches = exports.isObjectRef = void 0;
-const oids_js_1 = require("./oids.js");
-const refs_js_1 = require("./refs.js");
-const utils_js_1 = require("./utils.js");
-function isObjectRef(obj) {
-    return obj && typeof obj === 'object' && obj['@@type'] === 'ref';
-}
-exports.isObjectRef = isObjectRef;
-function isDiffableObject(val) {
-    return (0, utils_js_1.isObject)(val) && !(0, refs_js_1.isRef)(val);
-}
-function compareNonDiffable(a, b) {
-    if (a === b)
-        return true;
-    if ((0, refs_js_1.isRef)(a) && (0, refs_js_1.isRef)(b))
-        return (0, refs_js_1.compareRefs)(a, b);
-    return false;
-}
-function diffToPatches(from, to, getNow, keyPath, createSubId, patches = [], options = {}) {
-    const oid = (0, oids_js_1.getOid)(from);
-    function diffItems(key, value, oldValue) {
-        if (!isDiffableObject(value)) {
-            // for primitive fields, we can use plain sets and
-            // do not need to recurse, of course
-            if (!compareNonDiffable(value, oldValue)) {
-                patches.push({
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'set',
-                        name: key,
-                        value,
-                    },
-                });
-            }
-        }
-        else {
-            const oldValueOid = (0, oids_js_1.maybeGetOid)(oldValue);
-            let valueOid;
-            if (!options.mergeUnknownObjects) {
-                valueOid = (0, oids_js_1.ensureOid)(value, oid, key, createSubId);
-            }
-            else {
-                // if merge unknown objects is requested, we copy the previous value's oid
-                // to any mirrored new value if it doesn't have one assigned already.
-                valueOid = (0, oids_js_1.maybeGetOid)(value);
-                if (!valueOid && oldValueOid) {
-                    (0, oids_js_1.assignOid)(value, oldValueOid);
-                    valueOid = oldValueOid;
-                }
-                else {
-                    valueOid = (0, oids_js_1.ensureOid)(value, oid, key, createSubId);
-                }
-            }
-            if (oldValue === undefined || valueOid !== oldValueOid) {
-                // first case: previous value exists but the OIDs are different,
-                // meaning the object identity has changed
-                // we add the whole new object and also update the reference on this
-                // key of the parent to point to the new object
-                initialToPatches(value, valueOid, getNow, createSubId, patches);
-                patches.push({
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'set',
-                        name: key,
-                        value: (0, oids_js_1.createRef)(valueOid),
-                    },
-                });
-                // if there was an old value, we need to delete it altogether.
-                if (oldValueOid !== undefined) {
-                    patches.push({
-                        oid: oldValueOid,
-                        timestamp: getNow(),
-                        data: {
-                            op: 'delete',
-                        },
-                    });
-                }
-            }
-            else {
-                // third case: OIDs are the same, meaning the identity is the same,
-                // and we must diff the objects
-                diffToPatches(oldValue, value, getNow, [...keyPath, key], createSubId, patches, options);
-            }
-        }
-    }
-    if (Array.isArray(from) && Array.isArray(to)) {
-        // diffing is more naive than native array operations.
-        // we can only look at each element and decide if it should
-        // be replaced or removed - no moves or pushes, etc.
-        for (let i = 0; i < to.length; i++) {
-            const value = to[i];
-            const oldValue = from[i];
-            diffItems(i, value, oldValue);
-        }
-        // remove any remaining items at the end of the array
-        const deletedItemsAtEnd = from.length - to.length;
-        if (deletedItemsAtEnd > 0) {
-            // if sub-items were objects, we need to delete them all
-            for (let i = to.length; i < from.length; i++) {
-                const value = from[i];
-                const valueOid = (0, oids_js_1.maybeGetOid)(value);
-                if (valueOid) {
-                    patches.push({
-                        oid: valueOid,
-                        timestamp: getNow(),
-                        data: {
-                            op: 'delete',
-                        },
-                    });
-                }
-            }
-            // push the list-delete for the deleted items
-            patches.push({
-                oid,
-                timestamp: getNow(),
-                data: {
-                    op: 'list-delete',
-                    index: to.length,
-                    count: deletedItemsAtEnd,
-                },
-            });
-        }
-    }
-    else if (Array.isArray(from) || Array.isArray(to)) {
-        throw new Error('Cannot diff an array with an object');
-    }
-    else if (isDiffableObject(from) && isDiffableObject(to)) {
-        const oldKeys = new Set(Object.keys(from));
-        for (const [key, value] of Object.entries(to)) {
-            if (value === undefined && options.defaultUndefined)
-                continue;
-            oldKeys.delete(key);
-            if ((0, oids_js_1.isOidKey)(key))
-                continue;
-            const oldValue = from[key];
-            diffItems(key, value, oldValue);
-        }
-        // this set now only contains keys which were not in the new object
-        if (!options.defaultUndefined) {
-            for (const key of oldKeys) {
-                if ((0, oids_js_1.isOidKey)(key))
-                    continue;
-                // push the delete for the property
-                patches.push({
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'remove',
-                        name: key,
-                    },
-                });
-            }
-        }
-    }
-    return patches;
-}
-exports.diffToPatches = diffToPatches;
-function shallowDiffToPatches(from, to, getNow, patches = []) {
-    const oid = (0, oids_js_1.getOid)(from);
-    function diffItems(key, value, oldValue) {
-        if (!isDiffableObject(value)) {
-            // for primitive fields, we can use plain sets and
-            // do not need to recurse, of course
-            if (!compareNonDiffable(value, oldValue)) {
-                patches.push({
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'set',
-                        name: key,
-                        value,
-                    },
-                });
-            }
-        }
-        else {
-            throw new Error('Shallow diff was given a nested object. This is an error in verdant!');
-        }
-    }
-    if (Array.isArray(from) && Array.isArray(to)) {
-        // diffing is more naive than native array operations.
-        // we can only look at each element and decide if it should
-        // be replaced or removed - no moves or pushes, etc.
-        for (let i = 0; i < to.length; i++) {
-            const value = to[i];
-            const oldValue = from[i];
-            diffItems(i, value, oldValue);
-        }
-        // remove any remaining items at the end of the array
-        const deletedItemsAtEnd = from.length - to.length;
-        if (deletedItemsAtEnd > 0) {
-            // push the list-delete for the deleted items
-            patches.push({
-                oid,
-                timestamp: getNow(),
-                data: {
-                    op: 'list-delete',
-                    index: to.length,
-                    count: deletedItemsAtEnd,
-                },
-            });
-        }
-    }
-    else if (Array.isArray(from) || Array.isArray(to)) {
-        throw new Error('Cannot diff an array with an object');
-    }
-    else if (isDiffableObject(from) && isDiffableObject(to)) {
-        const oldKeys = new Set(Object.keys(from));
-        for (const [key, value] of Object.entries(to)) {
-            oldKeys.delete(key);
-            if ((0, oids_js_1.isOidKey)(key))
-                continue;
-            const oldValue = from[key];
-            diffItems(key, value, oldValue);
-        }
-        // this set now only contains keys which were not in the new object
-        for (const key of oldKeys) {
-            if ((0, oids_js_1.isOidKey)(key))
-                continue;
-            // push the delete for the property
-            patches.push({
-                oid,
-                timestamp: getNow(),
-                data: {
-                    op: 'remove',
-                    name: key,
-                },
-            });
-        }
-    }
-    return patches;
-}
-exports.shallowDiffToPatches = shallowDiffToPatches;
-/**
- * Takes a basic object and constructs a patch list to create it and
- * all of its nested objects.
- */
-function initialToPatches(initial, rootOid, getNow, createSubId, patches = []) {
-    (0, oids_js_1.assignOid)(initial, rootOid);
-    (0, oids_js_1.assignOidsToAllSubObjects)(initial, createSubId);
-    const normalized = (0, oids_js_1.normalize)(initial);
-    for (const key of normalized.keys()) {
-        const value = normalized.get(key);
-        patches.push({
-            oid: key,
-            timestamp: getNow(),
-            data: {
-                op: 'initialize',
-                value: (0, oids_js_1.removeOid)(value),
-            },
-        });
-    }
-    return patches;
-}
-exports.initialToPatches = initialToPatches;
-function shallowInitialToPatches(initial, rootOid, getNow, patches = []) {
-    patches.push({
-        oid: rootOid,
-        timestamp: getNow(),
-        data: {
-            op: 'initialize',
-            value: initial,
-        },
-    });
-    return patches;
-}
-exports.shallowInitialToPatches = shallowInitialToPatches;
-function groupPatchesByIdentifier(patches) {
-    const grouped = {};
-    for (const patch of patches) {
-        if (patch.oid in grouped) {
-            grouped[patch.oid].push(patch);
-        }
-        else {
-            grouped[patch.oid] = [patch];
-        }
-    }
-    return grouped;
-}
-exports.groupPatchesByIdentifier = groupPatchesByIdentifier;
-function groupPatchesByRootOid(patches) {
-    const grouped = {};
-    for (const patch of patches) {
-        const root = (0, oids_js_1.getOidRoot)(patch.oid);
-        if (root in grouped) {
-            grouped[root].push(patch);
-        }
-        else {
-            grouped[root] = [patch];
-        }
-    }
-    return grouped;
-}
-exports.groupPatchesByRootOid = groupPatchesByRootOid;
-function groupBaselinesByRootOid(baselines) {
-    const grouped = {};
-    for (const patch of baselines) {
-        const root = (0, oids_js_1.getOidRoot)(patch.oid);
-        if (root in grouped) {
-            grouped[root].push(patch);
-        }
-        else {
-            grouped[root] = [patch];
-        }
-    }
-    return grouped;
-}
-exports.groupBaselinesByRootOid = groupBaselinesByRootOid;
-function listCheck(obj) {
-    if (!Array.isArray(obj)) {
-        console.error(`Cannot apply list patch; expected array, received ${JSON.stringify(obj)}. This suggests your data is changing from a list to an object over time. (OID: ${(0, oids_js_1.maybeGetOid)(obj)})`);
-        return false;
-    }
-    else {
-        return true;
-    }
-}
-/**
- * The incoming object should already be normalized!
- * This function will mutate the base object.
- */
-function applyPatch(base, patch, 
-/**
- * Optionally supply a list to which any refs which
- * are removed during the patch will be appended.
- */
-deletedRefs) {
-    // deleted objects are represented by undefined
-    // and remain deleted unless re-initialized
-    if ((base === undefined || base === null) && patch.op !== 'initialize') {
-        return base;
-    }
-    // ditch typing internally.
-    const baseAsAny = base;
-    let index;
-    let spliceResult;
-    // a helper, pass it a value which is about
-    // to be removed and it will append it to the list
-    // if it was a ref
-    function checkRef(field) {
-        // don't bother if not supplied
-        if (!deletedRefs)
-            return;
-        if ((0, refs_js_1.isRef)(field)) {
-            deletedRefs.push(field);
-        }
-    }
-    switch (patch.op) {
-        case 'set':
-            checkRef(baseAsAny[patch.name]);
-            baseAsAny[patch.name] = patch.value;
-            break;
-        case 'remove':
-            checkRef(baseAsAny[patch.name]);
-            delete baseAsAny[patch.name];
-            break;
-        case 'list-push':
-            if (listCheck(base)) {
-                base.push(patch.value);
-            }
-            break;
-        case 'list-delete':
-            if (listCheck(base)) {
-                checkRef(base[patch.index]);
-                base.splice(patch.index, patch.count);
-            }
-            break;
-        case 'list-move-by-index':
-            if (listCheck(base)) {
-                spliceResult = base.splice(patch.from, 1);
-                base.splice(patch.to, 0, spliceResult[0]);
-            }
-            break;
-        case 'list-remove':
-            if (listCheck(base)) {
-                do {
-                    const valueToRemove = patch.value;
-                    if (patch.only === 'last') {
-                        if (isObjectRef(valueToRemove)) {
-                            index = (0, utils_js_1.findLastIndex)(base, (item) => item.id === valueToRemove.id);
-                        }
-                        else {
-                            index = base.lastIndexOf(valueToRemove);
-                        }
-                    }
-                    else {
-                        if (isObjectRef(valueToRemove)) {
-                            index = base.findIndex((item) => item.id === valueToRemove.id);
-                        }
-                        else {
-                            index = base.indexOf(valueToRemove);
-                        }
-                    }
-                    if (index !== -1) {
-                        checkRef(base[index]);
-                        base.splice(index, 1);
-                    }
-                } while (!patch.only && index !== -1);
-            }
-            break;
-        case 'list-add':
-            if (listCheck(base)) {
-                const alreadyHas = base.some((item) => {
-                    if (isObjectRef(item) && isObjectRef(patch.value)) {
-                        return item.id === patch.value.id;
-                    }
-                    else {
-                        return item === patch.value;
-                    }
-                });
-                if (!alreadyHas) {
-                    base.push(patch.value);
-                }
-            }
-            break;
-        case 'list-move-by-ref':
-            if (listCheck(base)) {
-                index = base.indexOf(patch.value);
-                spliceResult = base.splice(index, 1);
-                base.splice(patch.index, 0, spliceResult[0]);
-            }
-            break;
-        case 'list-insert':
-            if (listCheck(base)) {
-                if (!patch.value && !patch.values) {
-                    throw new Error(`Cannot apply list insert patch; expected value or values, received ${JSON.stringify(patch)}`);
-                }
-                if (patch.value) {
-                    base.splice(patch.index, 0, patch.value);
-                }
-                else {
-                    base.splice(patch.index, 0, ...patch.values);
-                }
-            }
-            break;
-        case 'delete':
-            // collect all refs that are deleted
-            if (Array.isArray(base)) {
-                base.forEach(checkRef);
-            }
-            else if ((0, utils_js_1.isObject)(base)) {
-                Object.values(base || {}).forEach(checkRef);
-            }
-            return undefined;
-        case 'initialize':
-            return (0, utils_js_1.cloneDeep)(patch.value);
-        default:
-            throw new Error(`Unsupported patch operation: ${patch.op}`);
-    }
-    return base;
-}
-exports.applyPatch = applyPatch;
-function applyOperations(base, operations, deletedRefs) {
-    let cur = base;
-    for (const op of operations) {
-        cur = applyPatch(cur, op.data, deletedRefs);
-    }
-    return cur;
-}
-exports.applyOperations = applyOperations;
-/**
- * Mutates the original object in place. Returns all referenced
- * objects oids.
- */
-function substituteRefsWithObjects(base, refs, used = []) {
-    if (Array.isArray(base)) {
-        for (let i = 0; i < base.length; i++) {
-            const item = base[i];
-            base[i] = dereference(item, refs, used);
-            if ((0, utils_js_1.isObject)(base[i])) {
-                substituteRefsWithObjects(base[i], refs, used);
-            }
-        }
-    }
-    else if ((0, utils_js_1.isObject)(base)) {
-        // not sure where to put this assertion but it's important to make
-        // sure all nested objects include an OID
-        (0, utils_js_1.assert)((0, oids_js_1.maybeGetOid)(base), `Object ${JSON.stringify(base)} must have an oid`);
-        for (const key of Object.keys(base)) {
-            base[key] = dereference(base[key], refs, used);
-            // now that objects are in place, recursively substitute
-            if ((0, utils_js_1.isObject)(base[key])) {
-                substituteRefsWithObjects(base[key], refs, used);
-            }
-        }
-    }
-    return used;
-}
-exports.substituteRefsWithObjects = substituteRefsWithObjects;
-function dereference(input, refs, used) {
-    if (isObjectRef(input)) {
-        used.push(input.id);
-        const resolved = refs.get(input.id);
-        (0, utils_js_1.assert)(!!resolved, `No value was found in object map for ${input.id}`);
-        return (0, oids_js_1.assignOid)(resolved, input.id);
-    }
-    else {
-        return input;
-    }
-}
-function substituteFirstLevelObjectsWithRefs(base, refObjects = new Map()) {
-    if (Array.isArray(base)) {
-        for (let i = 0; i < base.length; i++) {
-            const item = base[i];
-            if ((0, utils_js_1.isObject)(item)) {
-                const oid = (0, oids_js_1.getOid)(item);
-                base[i] = {
-                    '@@type': 'ref',
-                    id: oid,
-                };
-                refObjects.set(oid, item);
-            }
-        }
-    }
-    else {
-        for (const [key, value] of Object.entries(base)) {
-            if ((0, utils_js_1.isObject)(value)) {
-                base[key] = {
-                    '@@type': 'ref',
-                    id: (0, oids_js_1.getOid)(value),
-                };
-                refObjects.set((0, oids_js_1.getOid)(value), value);
-            }
-        }
-    }
-    return refObjects;
-}
-exports.substituteFirstLevelObjectsWithRefs = substituteFirstLevelObjectsWithRefs;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substituteFirstLevelObjectsWithRefs = exports.substituteRefsWithObjects = exports.applyOperations = exports.applyPatch = exports.groupBaselinesByRootOid = exports.groupPatchesByRootOid = exports.groupPatchesByIdentifier = exports.shallowInitialToPatches = exports.initialToPatches = exports.shallowDiffToPatches = exports.diffToPatches = exports.isObjectRef = void 0;
+const oids_js_1 = require("./oids.js");
+const refs_js_1 = require("./refs.js");
+const utils_js_1 = require("./utils.js");
+function isObjectRef(obj) {
+    return obj && typeof obj === 'object' && obj['@@type'] === 'ref';
+}
+exports.isObjectRef = isObjectRef;
+function isDiffableObject(val) {
+    return (0, utils_js_1.isObject)(val) && !(0, refs_js_1.isRef)(val);
+}
+function compareNonDiffable(a, b) {
+    if (a === b)
+        return true;
+    if ((0, refs_js_1.isRef)(a) && (0, refs_js_1.isRef)(b))
+        return (0, refs_js_1.compareRefs)(a, b);
+    return false;
+}
+function diffToPatches(from, to, getNow, createSubId, patches = [], options = {}) {
+    const oid = (0, oids_js_1.getOid)(from);
+    function diffItems(key, value, oldValue) {
+        if (!isDiffableObject(value)) {
+            // for primitive fields, we can use plain sets and
+            // do not need to recurse, of course
+            if (!compareNonDiffable(value, oldValue)) {
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value,
+                    },
+                });
+            }
+        }
+        else {
+            const oldValueOid = (0, oids_js_1.maybeGetOid)(oldValue);
+            let valueOid;
+            if (!options.mergeUnknownObjects) {
+                valueOid = (0, oids_js_1.ensureOid)(value, oid, createSubId);
+            }
+            else {
+                // if merge unknown objects is requested, we copy the previous value's oid
+                // to any mirrored new value if it doesn't have one assigned already.
+                valueOid = (0, oids_js_1.maybeGetOid)(value);
+                if (!valueOid && oldValueOid) {
+                    (0, oids_js_1.assignOid)(value, oldValueOid);
+                    valueOid = oldValueOid;
+                }
+                else {
+                    valueOid = (0, oids_js_1.ensureOid)(value, oid, createSubId);
+                }
+            }
+            if (oldValue === undefined || valueOid !== oldValueOid) {
+                // first case: previous value exists but the OIDs are different,
+                // meaning the object identity has changed
+                // we add the whole new object and also update the reference on this
+                // key of the parent to point to the new object
+                initialToPatches(value, valueOid, getNow, createSubId, patches);
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value: (0, oids_js_1.createRef)(valueOid),
+                    },
+                });
+                // if there was an old value, we need to delete it altogether.
+                if (oldValueOid !== undefined) {
+                    patches.push({
+                        oid: oldValueOid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'delete',
+                        },
+                    });
+                }
+            }
+            else {
+                // third case: OIDs are the same, meaning the identity is the same,
+                // and we must diff the objects
+                diffToPatches(oldValue, value, getNow, createSubId, patches, options);
+            }
+        }
+    }
+    if (Array.isArray(from) && Array.isArray(to)) {
+        // diffing is more naive than native array operations.
+        // we can only look at each element and decide if it should
+        // be replaced or removed - no moves or pushes, etc.
+        for (let i = 0; i < to.length; i++) {
+            const value = to[i];
+            const oldValue = from[i];
+            diffItems(i, value, oldValue);
+        }
+        // remove any remaining items at the end of the array
+        const deletedItemsAtEnd = from.length - to.length;
+        if (deletedItemsAtEnd > 0) {
+            // if sub-items were objects, we need to delete them all
+            for (let i = to.length; i < from.length; i++) {
+                const value = from[i];
+                const valueOid = (0, oids_js_1.maybeGetOid)(value);
+                if (valueOid) {
+                    patches.push({
+                        oid: valueOid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'delete',
+                        },
+                    });
+                }
+            }
+            // push the list-delete for the deleted items
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'list-delete',
+                    index: to.length,
+                    count: deletedItemsAtEnd,
+                },
+            });
+        }
+    }
+    else if (Array.isArray(from) || Array.isArray(to)) {
+        throw new Error('Cannot diff an array with an object');
+    }
+    else if (isDiffableObject(from) && isDiffableObject(to)) {
+        const oldKeys = new Set(Object.keys(from));
+        for (const [key, value] of Object.entries(to)) {
+            if (value === undefined && options.defaultUndefined)
+                continue;
+            oldKeys.delete(key);
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            const oldValue = from[key];
+            diffItems(key, value, oldValue);
+        }
+        // this set now only contains keys which were not in the new object
+        if (!options.defaultUndefined) {
+            for (const key of oldKeys) {
+                if ((0, oids_js_1.isOidKey)(key))
+                    continue;
+                // push the delete for the property
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'remove',
+                        name: key,
+                    },
+                });
+            }
+        }
+    }
+    return patches;
+}
+exports.diffToPatches = diffToPatches;
+function shallowDiffToPatches(from, to, getNow, patches = []) {
+    const oid = (0, oids_js_1.getOid)(from);
+    function diffItems(key, value, oldValue) {
+        if (!isDiffableObject(value)) {
+            // for primitive fields, we can use plain sets and
+            // do not need to recurse, of course
+            if (!compareNonDiffable(value, oldValue)) {
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value,
+                    },
+                });
+            }
+        }
+        else {
+            throw new Error('Shallow diff was given a nested object. This is an error in verdant!');
+        }
+    }
+    if (Array.isArray(from) && Array.isArray(to)) {
+        // diffing is more naive than native array operations.
+        // we can only look at each element and decide if it should
+        // be replaced or removed - no moves or pushes, etc.
+        for (let i = 0; i < to.length; i++) {
+            const value = to[i];
+            const oldValue = from[i];
+            diffItems(i, value, oldValue);
+        }
+        // remove any remaining items at the end of the array
+        const deletedItemsAtEnd = from.length - to.length;
+        if (deletedItemsAtEnd > 0) {
+            // push the list-delete for the deleted items
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'list-delete',
+                    index: to.length,
+                    count: deletedItemsAtEnd,
+                },
+            });
+        }
+    }
+    else if (Array.isArray(from) || Array.isArray(to)) {
+        throw new Error('Cannot diff an array with an object');
+    }
+    else if (isDiffableObject(from) && isDiffableObject(to)) {
+        const oldKeys = new Set(Object.keys(from));
+        for (const [key, value] of Object.entries(to)) {
+            oldKeys.delete(key);
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            const oldValue = from[key];
+            diffItems(key, value, oldValue);
+        }
+        // this set now only contains keys which were not in the new object
+        for (const key of oldKeys) {
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            // push the delete for the property
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'remove',
+                    name: key,
+                },
+            });
+        }
+    }
+    return patches;
+}
+exports.shallowDiffToPatches = shallowDiffToPatches;
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+function initialToPatches(initial, rootOid, getNow, createSubId, patches = []) {
+    (0, oids_js_1.assignOid)(initial, rootOid);
+    (0, oids_js_1.assignOidsToAllSubObjects)(initial, createSubId);
+    const normalized = (0, oids_js_1.normalize)(initial);
+    for (const key of normalized.keys()) {
+        const value = normalized.get(key);
+        patches.push({
+            oid: key,
+            timestamp: getNow(),
+            data: {
+                op: 'initialize',
+                value: (0, oids_js_1.removeOid)(value),
+            },
+        });
+    }
+    return patches;
+}
+exports.initialToPatches = initialToPatches;
+function shallowInitialToPatches(initial, rootOid, getNow, patches = []) {
+    patches.push({
+        oid: rootOid,
+        timestamp: getNow(),
+        data: {
+            op: 'initialize',
+            value: initial,
+        },
+    });
+    return patches;
+}
+exports.shallowInitialToPatches = shallowInitialToPatches;
+function groupPatchesByIdentifier(patches) {
+    const grouped = {};
+    for (const patch of patches) {
+        if (patch.oid in grouped) {
+            grouped[patch.oid].push(patch);
+        }
+        else {
+            grouped[patch.oid] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupPatchesByIdentifier = groupPatchesByIdentifier;
+function groupPatchesByRootOid(patches) {
+    const grouped = {};
+    for (const patch of patches) {
+        const root = (0, oids_js_1.getOidRoot)(patch.oid);
+        if (root in grouped) {
+            grouped[root].push(patch);
+        }
+        else {
+            grouped[root] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupPatchesByRootOid = groupPatchesByRootOid;
+function groupBaselinesByRootOid(baselines) {
+    const grouped = {};
+    for (const patch of baselines) {
+        const root = (0, oids_js_1.getOidRoot)(patch.oid);
+        if (root in grouped) {
+            grouped[root].push(patch);
+        }
+        else {
+            grouped[root] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupBaselinesByRootOid = groupBaselinesByRootOid;
+function listCheck(obj) {
+    if (!Array.isArray(obj)) {
+        console.error(`Cannot apply list patch; expected array, received ${JSON.stringify(obj)}. This suggests your data is changing from a list to an object over time. (OID: ${(0, oids_js_1.maybeGetOid)(obj)})`);
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+function applyPatch(base, patch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs) {
+    // deleted objects are represented by undefined
+    // and remain deleted unless re-initialized
+    if ((base === undefined || base === null) && patch.op !== 'initialize') {
+        return base;
+    }
+    // ditch typing internally.
+    const baseAsAny = base;
+    let index;
+    let spliceResult;
+    // a helper, pass it a value which is about
+    // to be removed and it will append it to the list
+    // if it was a ref
+    function checkRef(field) {
+        // don't bother if not supplied
+        if (!deletedRefs)
+            return;
+        if ((0, refs_js_1.isRef)(field)) {
+            deletedRefs.push(field);
+        }
+    }
+    switch (patch.op) {
+        case 'set':
+            checkRef(baseAsAny[patch.name]);
+            baseAsAny[patch.name] = patch.value;
+            break;
+        case 'remove':
+            checkRef(baseAsAny[patch.name]);
+            delete baseAsAny[patch.name];
+            break;
+        case 'list-push':
+            if (listCheck(base)) {
+                base.push(patch.value);
+            }
+            break;
+        case 'list-delete':
+            if (listCheck(base)) {
+                checkRef(base[patch.index]);
+                base.splice(patch.index, patch.count);
+            }
+            break;
+        case 'list-move-by-index':
+            if (listCheck(base)) {
+                spliceResult = base.splice(patch.from, 1);
+                base.splice(patch.to, 0, spliceResult[0]);
+            }
+            break;
+        case 'list-remove':
+            if (listCheck(base)) {
+                do {
+                    const valueToRemove = patch.value;
+                    if (patch.only === 'last') {
+                        if (isObjectRef(valueToRemove)) {
+                            index = (0, utils_js_1.findLastIndex)(base, (item) => item.id === valueToRemove.id);
+                        }
+                        else {
+                            index = base.lastIndexOf(valueToRemove);
+                        }
+                    }
+                    else {
+                        if (isObjectRef(valueToRemove)) {
+                            index = base.findIndex((item) => item.id === valueToRemove.id);
+                        }
+                        else {
+                            index = base.indexOf(valueToRemove);
+                        }
+                    }
+                    if (index !== -1) {
+                        checkRef(base[index]);
+                        base.splice(index, 1);
+                    }
+                } while (!patch.only && index !== -1);
+            }
+            break;
+        case 'list-add':
+            if (listCheck(base)) {
+                const alreadyHas = base.some((item) => {
+                    if (isObjectRef(item) && isObjectRef(patch.value)) {
+                        return item.id === patch.value.id;
+                    }
+                    else {
+                        return item === patch.value;
+                    }
+                });
+                if (!alreadyHas) {
+                    base.push(patch.value);
+                }
+            }
+            break;
+        case 'list-move-by-ref':
+            if (listCheck(base)) {
+                index = base.indexOf(patch.value);
+                spliceResult = base.splice(index, 1);
+                base.splice(patch.index, 0, spliceResult[0]);
+            }
+            break;
+        case 'list-insert':
+            if (listCheck(base)) {
+                if (!patch.value && !patch.values) {
+                    throw new Error(`Cannot apply list insert patch; expected value or values, received ${JSON.stringify(patch)}`);
+                }
+                if (patch.value) {
+                    base.splice(patch.index, 0, patch.value);
+                }
+                else {
+                    base.splice(patch.index, 0, ...patch.values);
+                }
+            }
+            break;
+        case 'delete':
+            // collect all refs that are deleted
+            if (Array.isArray(base)) {
+                base.forEach(checkRef);
+            }
+            else if ((0, utils_js_1.isObject)(base)) {
+                Object.values(base || {}).forEach(checkRef);
+            }
+            return undefined;
+        case 'initialize':
+            return (0, utils_js_1.cloneDeep)(patch.value);
+        default:
+            throw new Error(`Unsupported patch operation: ${patch.op}`);
+    }
+    return base;
+}
+exports.applyPatch = applyPatch;
+function applyOperations(base, operations, deletedRefs) {
+    let cur = base;
+    for (const op of operations) {
+        cur = applyPatch(cur, op.data, deletedRefs);
+    }
+    return cur;
+}
+exports.applyOperations = applyOperations;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+function substituteRefsWithObjects(base, refs, used = []) {
+    if (Array.isArray(base)) {
+        for (let i = 0; i < base.length; i++) {
+            const item = base[i];
+            base[i] = dereference(item, refs, used);
+            if ((0, utils_js_1.isObject)(base[i])) {
+                substituteRefsWithObjects(base[i], refs, used);
+            }
+        }
+    }
+    else if ((0, utils_js_1.isObject)(base)) {
+        // not sure where to put this assertion but it's important to make
+        // sure all nested objects include an OID
+        (0, utils_js_1.assert)((0, oids_js_1.maybeGetOid)(base), `Object ${JSON.stringify(base)} must have an oid`);
+        for (const key of Object.keys(base)) {
+            base[key] = dereference(base[key], refs, used);
+            // now that objects are in place, recursively substitute
+            if ((0, utils_js_1.isObject)(base[key])) {
+                substituteRefsWithObjects(base[key], refs, used);
+            }
+        }
+    }
+    return used;
+}
+exports.substituteRefsWithObjects = substituteRefsWithObjects;
+function dereference(input, refs, used) {
+    if (isObjectRef(input)) {
+        used.push(input.id);
+        const resolved = refs.get(input.id);
+        (0, utils_js_1.assert)(!!resolved, `No value was found in object map for ${input.id}`);
+        return (0, oids_js_1.assignOid)(resolved, input.id);
+    }
+    else {
+        return input;
+    }
+}
+function substituteFirstLevelObjectsWithRefs(base, refObjects = new Map()) {
+    if (Array.isArray(base)) {
+        for (let i = 0; i < base.length; i++) {
+            const item = base[i];
+            if ((0, utils_js_1.isObject)(item)) {
+                const oid = (0, oids_js_1.getOid)(item);
+                base[i] = {
+                    '@@type': 'ref',
+                    id: oid,
+                };
+                refObjects.set(oid, item);
+            }
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(base)) {
+            if ((0, utils_js_1.isObject)(value)) {
+                base[key] = {
+                    '@@type': 'ref',
+                    id: (0, oids_js_1.getOid)(value),
+                };
+                refObjects.set((0, oids_js_1.getOid)(value), value);
+            }
+        }
+    }
+    return refObjects;
+}
+exports.substituteFirstLevelObjectsWithRefs = substituteFirstLevelObjectsWithRefs;
 //# sourceMappingURL=operation.js.map