json-diff-ts 1.2.6 → 2.1.0

package/lib/jsonDiff.d.ts

@@ -1,9 +1,6 @@
-import { Dictionary } from 'lodash';
-declare type FunctionKey = (obj: any, getKeyName?: boolean) => any;
-export declare const getTypeOfObj: (obj: any) => string;
-export declare const diff: (oldObj: any, newObj: any, embeddedObjKeys?: Dictionary<string | FunctionKey>) => IChange[];
-export declare const applyChangeset: (obj: any, changeset: Changeset) => any;
-export declare const revertChangeset: (obj: any, changeset: Changeset) => any;
+type FunctionKey = (obj: any, shouldReturnKeyName?: boolean) => any;
+export type EmbeddedObjKeysType = Record<string, string | FunctionKey>;
+export type EmbeddedObjKeysMapType = Map<string | RegExp, string | FunctionKey>;
 export declare enum Operation {
     REMOVE = "REMOVE",
     ADD = "ADD",
@@ -17,7 +14,7 @@ export interface IChange {
     oldValue?: any;
     changes?: IChange[];
 }
-export declare type Changeset = IChange[];
+export type Changeset = IChange[];
 export interface IFlatChange {
     type: Operation;
     key: string;
@@ -26,6 +23,76 @@ export interface IFlatChange {
     value?: any;
     oldValue?: any;
 }
+/**
+ * Computes the difference between two objects.
+ *
+ * @param {any} oldObj - The original object.
+ * @param {any} newObj - The updated object.
+ * @param {EmbeddedObjKeysType | EmbeddedObjKeysMapType} embeddedObjKeys - An optional parameter specifying keys of embedded objects.
+ * @returns {IChange[]} - An array of changes that transform the old object into the new object.
+ */
+export declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType): IChange[];
+/**
+ * Applies all changes in the changeset to the object.
+ *
+ * @param {any} obj - The object to apply changes to.
+ * @param {Changeset} changeset - The changeset to apply.
+ * @returns {any} - The object after the changes from the changeset have been applied.
+ *
+ * The function first checks if a changeset is provided. If so, it iterates over each change in the changeset.
+ * If the change value is not null or undefined, or if the change type is REMOVE, it applies the change to the object directly.
+ * Otherwise, it applies the change to the corresponding branch of the object.
+ */
+export declare const applyChangeset: (obj: any, changeset: Changeset) => any;
+/**
+ * Reverts the changes made to an object based on a given changeset.
+ *
+ * @param {any} obj - The object on which to revert changes.
+ * @param {Changeset} changeset - The changeset to revert.
+ * @returns {any} - The object after the changes from the changeset have been reverted.
+ *
+ * The function first checks if a changeset is provided. If so, it reverses the changeset to start reverting from the last change.
+ * It then iterates over each change in the changeset. If the change does not have any nested changes, it reverts the change on the object directly.
+ * If the change does have nested changes, it reverts the changes on the corresponding branch of the object.
+ */
+export declare const revertChangeset: (obj: any, changeset: Changeset) => any;
+/**
+ * Flattens a changeset into an array of flat changes.
+ *
+ * @param {Changeset | IChange} obj - The changeset or change to flatten.
+ * @param {string} [path='$'] - The current path in the changeset.
+ * @param {string | FunctionKey} [embeddedKey] - The key to use for embedded objects.
+ * @returns {IFlatChange[]} - An array of flat changes.
+ *
+ * The function first checks if the input is an array. If so, it recursively flattens each change in the array.
+ * If the input is not an array, it checks if the change has nested changes or an embedded key.
+ * If so, it updates the path and recursively flattens the nested changes or the embedded object.
+ * If the change does not have nested changes or an embedded key, it creates a flat change and returns it in an array.
+ */
 export declare const flattenChangeset: (obj: Changeset | IChange, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
+/**
+ * Transforms a flat changeset into a nested changeset.
+ *
+ * @param {IFlatChange | IFlatChange[]} changes - The flat changeset to unflatten.
+ * @returns {IChange[]} - The unflattened changeset.
+ *
+ * The function first checks if the input is a single change or an array of changes.
+ * It then iterates over each change and splits its path into segments.
+ * For each segment, it checks if it represents an array or a leaf node.
+ * If it represents an array, it creates a new change object and updates the pointer to this new object.
+ * If it represents a leaf node, it sets the key, type, value, and oldValue of the current change object.
+ * Finally, it pushes the unflattened change object into the changes array.
+ */
 export declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) => IChange[];
+/**
+ * Determines the type of a given object.
+ *
+ * @param {any} obj - The object whose type is to be determined.
+ * @returns {string | null} - The type of the object, or null if the object is null.
+ *
+ * This function first checks if the object is undefined or null, and returns 'undefined' or null respectively.
+ * If the object is neither undefined nor null, it uses Object.prototype.toString to get the object's type.
+ * The type is extracted from the string returned by Object.prototype.toString using a regular expression.
+ */
+export declare const getTypeOfObj: (obj: any) => string;
 export {};

package/lib/jsonDiff.js

@@ -1,25 +1,262 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unflattenChanges = exports.flattenChangeset = exports.Operation = exports.revertChangeset = exports.applyChangeset = exports.diff = exports.getTypeOfObj = void 0;
-const lodash_1 = require("lodash");
-const getTypeOfObj = (obj) => {
+import { difference, find, intersection, keyBy } from 'lodash-es';
+export var Operation;
+(function (Operation) {
+    Operation["REMOVE"] = "REMOVE";
+    Operation["ADD"] = "ADD";
+    Operation["UPDATE"] = "UPDATE";
+})(Operation || (Operation = {}));
+/**
+ * Computes the difference between two objects.
+ *
+ * @param {any} oldObj - The original object.
+ * @param {any} newObj - The updated object.
+ * @param {EmbeddedObjKeysType | EmbeddedObjKeysMapType} embeddedObjKeys - An optional parameter specifying keys of embedded objects.
+ * @returns {IChange[]} - An array of changes that transform the old object into the new object.
+ */
+export function diff(oldObj, newObj, embeddedObjKeys) {
+    // Trim leading '.' from keys in embeddedObjKeys
+    if (embeddedObjKeys instanceof Map) {
+        embeddedObjKeys = new Map(Array.from(embeddedObjKeys.entries()).map(([key, value]) => [
+            key instanceof RegExp ? key : key.replace(/^\./, ''),
+            value
+        ]));
+    }
+    else if (embeddedObjKeys) {
+        embeddedObjKeys = Object.fromEntries(Object.entries(embeddedObjKeys).map(([key, value]) => [key.replace(/^\./, ''), value]));
+    }
+    // Compare old and new objects to generate a list of changes
+    return compare(oldObj, newObj, [], embeddedObjKeys, []);
+}
+/**
+ * Applies all changes in the changeset to the object.
+ *
+ * @param {any} obj - The object to apply changes to.
+ * @param {Changeset} changeset - The changeset to apply.
+ * @returns {any} - The object after the changes from the changeset have been applied.
+ *
+ * The function first checks if a changeset is provided. If so, it iterates over each change in the changeset.
+ * If the change value is not null or undefined, or if the change type is REMOVE, it applies the change to the object directly.
+ * Otherwise, it applies the change to the corresponding branch of the object.
+ */
+export const applyChangeset = (obj, changeset) => {
+    if (changeset) {
+        changeset.forEach((change) => {
+            const { type, key, value, embeddedKey } = change;
+            if ((value !== null && value !== undefined) || type === Operation.REMOVE) {
+                // Apply the change to the object
+                applyLeafChange(obj, change, embeddedKey);
+            }
+            else {
+                // Apply the change to the branch
+                applyBranchChange(obj[key], change);
+            }
+        });
+    }
+    return obj;
+};
+/**
+ * Reverts the changes made to an object based on a given changeset.
+ *
+ * @param {any} obj - The object on which to revert changes.
+ * @param {Changeset} changeset - The changeset to revert.
+ * @returns {any} - The object after the changes from the changeset have been reverted.
+ *
+ * The function first checks if a changeset is provided. If so, it reverses the changeset to start reverting from the last change.
+ * It then iterates over each change in the changeset. If the change does not have any nested changes, it reverts the change on the object directly.
+ * If the change does have nested changes, it reverts the changes on the corresponding branch of the object.
+ */
+export const revertChangeset = (obj, changeset) => {
+    if (changeset) {
+        changeset
+            .reverse()
+            .forEach((change) => !change.changes ? revertLeafChange(obj, change) : revertBranchChange(obj[change.key], change));
+    }
+    return obj;
+};
+/**
+ * Flattens a changeset into an array of flat changes.
+ *
+ * @param {Changeset | IChange} obj - The changeset or change to flatten.
+ * @param {string} [path='$'] - The current path in the changeset.
+ * @param {string | FunctionKey} [embeddedKey] - The key to use for embedded objects.
+ * @returns {IFlatChange[]} - An array of flat changes.
+ *
+ * The function first checks if the input is an array. If so, it recursively flattens each change in the array.
+ * If the input is not an array, it checks if the change has nested changes or an embedded key.
+ * If so, it updates the path and recursively flattens the nested changes or the embedded object.
+ * If the change does not have nested changes or an embedded key, it creates a flat change and returns it in an array.
+ */
+export const flattenChangeset = (obj, path = '$', embeddedKey) => {
+    if (Array.isArray(obj)) {
+        return obj.reduce((memo, change) => [...memo, ...flattenChangeset(change, path, embeddedKey)], []);
+    }
+    else {
+        if (obj.changes || embeddedKey) {
+            path = embeddedKey
+                ? embeddedKey === '$index'
+                    ? `${path}[${obj.key}]`
+                    : obj.type === Operation.ADD
+                        ? path
+                        : filterExpression(path, embeddedKey, obj.key)
+                : (path = append(path, obj.key));
+            return flattenChangeset(obj.changes || obj, path, obj.embeddedKey);
+        }
+        else {
+            const valueType = getTypeOfObj(obj.value);
+            return [
+                {
+                    ...obj,
+                    path: valueType === 'Object' || path.endsWith(`[${obj.key}]`) ? path : append(path, obj.key),
+                    valueType
+                }
+            ];
+        }
+    }
+};
+/**
+ * Transforms a flat changeset into a nested changeset.
+ *
+ * @param {IFlatChange | IFlatChange[]} changes - The flat changeset to unflatten.
+ * @returns {IChange[]} - The unflattened changeset.
+ *
+ * The function first checks if the input is a single change or an array of changes.
+ * It then iterates over each change and splits its path into segments.
+ * For each segment, it checks if it represents an array or a leaf node.
+ * If it represents an array, it creates a new change object and updates the pointer to this new object.
+ * If it represents a leaf node, it sets the key, type, value, and oldValue of the current change object.
+ * Finally, it pushes the unflattened change object into the changes array.
+ */
+export const unflattenChanges = (changes) => {
+    if (!Array.isArray(changes)) {
+        changes = [changes];
+    }
+    const changesArr = [];
+    changes.forEach((change) => {
+        const obj = {};
+        let ptr = obj;
+        const segments = change.path.split(/(?<=[^@])\.(?=[^@])/);
+        if (segments.length === 1) {
+            ptr.key = change.key;
+            ptr.type = change.type;
+            ptr.value = change.value;
+            ptr.oldValue = change.oldValue;
+            changesArr.push(ptr);
+        }
+        else {
+            for (let i = 1; i < segments.length; i++) {
+                const segment = segments[i];
+                // Matches JSONPath segments: "items[?(@.id=='123')]", items[?(@.id==123)], "items[2]"
+                const result = /^(.+)\[\?\(@\.([^=]+)={1,2}(?:'(.*)'|(\d+))\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
+                // array
+                if (result) {
+                    let key;
+                    let embeddedKey;
+                    let arrKey;
+                    if (result[1]) {
+                        key = result[1];
+                        embeddedKey = result[2];
+                        arrKey = result[3];
+                    }
+                    else {
+                        key = result[5];
+                        embeddedKey = '$index';
+                        arrKey = Number(result[6]);
+                    }
+                    // leaf
+                    if (i === segments.length - 1) {
+                        ptr.key = key;
+                        ptr.embeddedKey = embeddedKey;
+                        ptr.type = Operation.UPDATE;
+                        ptr.changes = [
+                            {
+                                type: change.type,
+                                key: arrKey,
+                                value: change.value,
+                                oldValue: change.oldValue
+                            }
+                        ];
+                    }
+                    else {
+                        // object
+                        ptr.key = key;
+                        ptr.embeddedKey = embeddedKey;
+                        ptr.type = Operation.UPDATE;
+                        const newPtr = {};
+                        ptr.changes = [
+                            {
+                                type: Operation.UPDATE,
+                                key: arrKey,
+                                changes: [newPtr]
+                            }
+                        ];
+                        ptr = newPtr;
+                    }
+                }
+                else {
+                    // leaf
+                    if (i === segments.length - 1) {
+                        // check if value is a primitive or object
+                        if (change.value !== null && change.valueType === 'Object') {
+                            ptr.key = segment;
+                            ptr.type = Operation.UPDATE;
+                            ptr.changes = [
+                                {
+                                    key: change.key,
+                                    type: change.type,
+                                    value: change.value
+                                }
+                            ];
+                        }
+                        else {
+                            ptr.key = change.key;
+                            ptr.type = change.type;
+                            ptr.value = change.value;
+                            ptr.oldValue = change.oldValue;
+                        }
+                    }
+                    else {
+                        // branch
+                        ptr.key = segment;
+                        ptr.type = Operation.UPDATE;
+                        const newPtr = {};
+                        ptr.changes = [newPtr];
+                        ptr = newPtr;
+                    }
+                }
+            }
+            changesArr.push(obj);
+        }
+    });
+    return changesArr;
+};
+/**
+ * Determines the type of a given object.
+ *
+ * @param {any} obj - The object whose type is to be determined.
+ * @returns {string | null} - The type of the object, or null if the object is null.
+ *
+ * This function first checks if the object is undefined or null, and returns 'undefined' or null respectively.
+ * If the object is neither undefined nor null, it uses Object.prototype.toString to get the object's type.
+ * The type is extracted from the string returned by Object.prototype.toString using a regular expression.
+ */
+export const getTypeOfObj = (obj) => {
     if (typeof obj === 'undefined') {
         return 'undefined';
     }
     if (obj === null) {
         return null;
     }
+    // Extracts the "Type" from "[object Type]" string.
     return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
 };
-exports.getTypeOfObj = getTypeOfObj;
 const getKey = (path) => {
     const left = path[path.length - 1];
     return left != null ? left : '$root';
 };
 const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
     let changes = [];
-    const typeOfOldObj = (0, exports.getTypeOfObj)(oldObj);
-    const typeOfNewObj = (0, exports.getTypeOfObj)(newObj);
+    const typeOfOldObj = getTypeOfObj(oldObj);
+    const typeOfNewObj = getTypeOfObj(newObj);
     // if type of object changes, consider it as old obj has been deleted and a new object has been added
     if (typeOfOldObj !== typeOfNewObj) {
         changes.push({ type: Operation.REMOVE, key: getKey(path), value: oldObj });
@@ -28,7 +265,11 @@ const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
     }
     switch (typeOfOldObj) {
         case 'Date':
-            changes = changes.concat(comparePrimitives(oldObj.getTime(), newObj.getTime(), path).map((x) => (Object.assign(Object.assign({}, x), { value: new Date(x.value), oldValue: new Date(x.oldValue) }))));
+            changes = changes.concat(comparePrimitives(oldObj.getTime(), newObj.getTime(), path).map((x) => ({
+                ...x,
+                value: new Date(x.value),
+                oldValue: new Date(x.oldValue)
+            })));
             break;
         case 'Object':
             const diffs = compareObject(oldObj, newObj, path, embeddedObjKeys, keyPath);
@@ -66,7 +307,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
     let changes = [];
     const oldObjKeys = Object.keys(oldObj);
     const newObjKeys = Object.keys(newObj);
-    const intersectionKeys = (0, lodash_1.intersection)(oldObjKeys, newObjKeys);
+    const intersectionKeys = intersection(oldObjKeys, newObjKeys);
     for (k of intersectionKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -75,7 +316,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             changes = changes.concat(diffs);
         }
     }
-    const addedKeys = (0, lodash_1.difference)(newObjKeys, oldObjKeys);
+    const addedKeys = difference(newObjKeys, oldObjKeys);
     for (k of addedKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -85,7 +326,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             value: newObj[k]
         });
     }
-    const deletedKeys = (0, lodash_1.difference)(oldObjKeys, newObjKeys);
+    const deletedKeys = difference(oldObjKeys, newObjKeys);
     for (k of deletedKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -120,22 +361,29 @@ const compareArray = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
 const getObjectKey = (embeddedObjKeys, keyPath) => {
     if (embeddedObjKeys != null) {
         const path = keyPath.join('.');
+        if (embeddedObjKeys instanceof Map) {
+            for (const [key, value] of embeddedObjKeys.entries()) {
+                if (key instanceof RegExp) {
+                    if (path.match(key)) {
+                        return value;
+                    }
+                }
+                else if (path === key) {
+                    return value;
+                }
+            }
+        }
         const key = embeddedObjKeys[path];
         if (key != null) {
             return key;
         }
-        for (const regex in embeddedObjKeys) {
-            if (path.match(new RegExp(regex))) {
-                return embeddedObjKeys[regex];
-            }
-        }
     }
     return undefined;
 };
 const convertArrayToObj = (arr, uniqKey) => {
     let obj = {};
     if (uniqKey !== '$index') {
-        obj = (0, lodash_1.keyBy)(arr, uniqKey);
+        obj = keyBy(arr, uniqKey);
     }
     else {
         for (let i = 0; i < arr.length; i++) {
@@ -157,7 +405,6 @@ const comparePrimitives = (oldObj, newObj, path) => {
     }
     return changes;
 };
-// const isEmbeddedKey = key => /\$.*=/gi.test(key)
 const removeKey = (obj, key, embeddedKey) => {
     if (Array.isArray(obj)) {
         if (embeddedKey === '$index') {
@@ -219,9 +466,9 @@ const applyArrayChange = (arr, change) => (() => {
                 element = arr[subchange.key];
             }
             else {
-                element = (0, lodash_1.find)(arr, (el) => el[change.embeddedKey].toString() === subchange.key.toString());
+                element = find(arr, (el) => el[change.embeddedKey]?.toString() === subchange.key.toString());
             }
-            result.push((0, exports.applyChangeset)(element, subchange.changes));
+            result.push(applyChangeset(element, subchange.changes));
         }
     }
     return result;
@@ -231,7 +478,7 @@ const applyBranchChange = (obj, change) => {
         return applyArrayChange(obj, change);
     }
     else {
-        return (0, exports.applyChangeset)(obj, change.changes);
+        return applyChangeset(obj, change.changes);
     }
 };
 const revertLeafChange = (obj, change, embeddedKey = '$index') => {
@@ -257,9 +504,9 @@ const revertArrayChange = (arr, change) => (() => {
                 element = arr[+subchange.key];
             }
             else {
-                element = (0, lodash_1.find)(arr, (el) => el[change.embeddedKey].toString() === subchange.key);
+                element = find(arr, (el) => el[change.embeddedKey].toString() === subchange.key);
             }
-            result.push((0, exports.revertChangeset)(element, subchange.changes));
+            result.push(revertChangeset(element, subchange.changes));
         }
     }
     return result;
@@ -269,186 +516,17 @@ const revertBranchChange = (obj, change) => {
         return revertArrayChange(obj, change);
     }
     else {
-        return (0, exports.revertChangeset)(obj, change.changes);
-    }
-};
-const diff = (oldObj, newObj, embeddedObjKeys) => compare(oldObj, newObj, [], embeddedObjKeys, []);
-exports.diff = diff;
-const applyChangeset = (obj, changeset) => {
-    if (changeset) {
-        changeset.forEach((change) => (change.value !== null && change.value !== undefined) || change.type === Operation.REMOVE
-            ? applyLeafChange(obj, change, change.embeddedKey)
-            : applyBranchChange(obj[change.key], change));
-    }
-    return obj;
-};
-exports.applyChangeset = applyChangeset;
-const revertChangeset = (obj, changeset) => {
-    if (changeset) {
-        changeset
-            .reverse()
-            .forEach((change) => !change.changes ? revertLeafChange(obj, change) : revertBranchChange(obj[change.key], change));
+        return revertChangeset(obj, change.changes);
     }
-    return obj;
-};
-exports.revertChangeset = revertChangeset;
-var Operation;
-(function (Operation) {
-    Operation["REMOVE"] = "REMOVE";
-    Operation["ADD"] = "ADD";
-    Operation["UPDATE"] = "UPDATE";
-})(Operation = exports.Operation || (exports.Operation = {}));
-const flattenChangeset = (obj, path = '$', embeddedKey) => {
-    if (Array.isArray(obj)) {
-        return obj.reduce((memo, change) => [...memo, ...(0, exports.flattenChangeset)(change, path, embeddedKey)], []);
-    }
-    else {
-        if (obj.changes || embeddedKey) {
-            path = embeddedKey
-                ? embeddedKey === '$index'
-                    ? `${path}[${obj.key}]`
-                    : obj.type === Operation.ADD
-                        ? path
-                        : filterExpression(path, embeddedKey, obj.key)
-                : (path = append(path, obj.key));
-            return (0, exports.flattenChangeset)(obj.changes || obj, path, obj.embeddedKey);
-        }
-        else {
-            const valueType = (0, exports.getTypeOfObj)(obj.value);
-            return [
-                Object.assign(Object.assign({}, obj), { path: valueType === 'Object' || path.endsWith(`[${obj.key}]`)
-                        ? path
-                        : append(path, obj.key), valueType })
-            ];
-        }
-    }
-};
-exports.flattenChangeset = flattenChangeset;
-const unflattenChanges = (changes) => {
-    if (!Array.isArray(changes)) {
-        changes = [changes];
-    }
-    const changesArr = [];
-    changes.forEach((change) => {
-        const obj = {};
-        let ptr = obj;
-        const segments = change.path.split(/([^@])\./).reduce((acc, curr, i) => {
-            const x = Math.floor(i / 2);
-            if (!acc[x]) {
-                acc[x] = '';
-            }
-            acc[x] += curr;
-            return acc;
-        }, []);
-        // $.childern[@.name='chris'].age
-        // =>
-        // $
-        // childern[@.name='chris']
-        // age
-        if (segments.length === 1) {
-            ptr.key = change.key;
-            ptr.type = change.type;
-            ptr.value = change.value;
-            ptr.oldValue = change.oldValue;
-            changesArr.push(ptr);
-        }
-        else {
-            for (let i = 1; i < segments.length; i++) {
-                const segment = segments[i];
-                // check for array
-                const result = /^(.+)\[\?\(@\.(.+)='(.+)'\)]$|^(.+)\[(\d+)\]/.exec(segment);
-                // array
-                if (result) {
-                    let key;
-                    let embeddedKey;
-                    let arrKey;
-                    if (result[1]) {
-                        key = result[1];
-                        embeddedKey = result[2];
-                        arrKey = result[3];
-                    }
-                    else {
-                        key = result[4];
-                        embeddedKey = '$index';
-                        arrKey = Number(result[5]);
-                    }
-                    // leaf
-                    if (i === segments.length - 1) {
-                        ptr.key = key;
-                        ptr.embeddedKey = embeddedKey;
-                        ptr.type = Operation.UPDATE;
-                        ptr.changes = [
-                            {
-                                type: change.type,
-                                key: arrKey,
-                                value: change.value,
-                                oldValue: change.oldValue
-                            }
-                        ];
-                    }
-                    else {
-                        // object
-                        ptr.key = key;
-                        ptr.embeddedKey = embeddedKey;
-                        ptr.type = Operation.UPDATE;
-                        const newPtr = {};
-                        ptr.changes = [
-                            {
-                                type: Operation.UPDATE,
-                                key: arrKey,
-                                changes: [newPtr]
-                            }
-                        ];
-                        ptr = newPtr;
-                    }
-                }
-                else {
-                    // leaf
-                    if (i === segments.length - 1) {
-                        // check if value is a primitive or object
-                        if (change.value !== null && change.valueType === 'Object') {
-                            ptr.key = segment;
-                            ptr.type = Operation.UPDATE;
-                            ptr.changes = [
-                                {
-                                    key: change.key,
-                                    type: change.type,
-                                    value: change.value
-                                }
-                            ];
-                        }
-                        else {
-                            ptr.key = change.key;
-                            ptr.type = change.type;
-                            ptr.value = change.value;
-                            ptr.oldValue = change.oldValue;
-                        }
-                    }
-                    else {
-                        // branch
-                        ptr.key = segment;
-                        ptr.type = Operation.UPDATE;
-                        const newPtr = {};
-                        ptr.changes = [newPtr];
-                        ptr = newPtr;
-                    }
-                }
-            }
-            changesArr.push(obj);
-        }
-    });
-    return changesArr;
 };
-exports.unflattenChanges = unflattenChanges;
 /** combine a base JSON Path with a subsequent segment */
 function append(basePath, nextSegment) {
-    return nextSegment.includes('.')
-        ? `${basePath}[${nextSegment}]`
-        : `${basePath}.${nextSegment}`;
+    return nextSegment.includes('.') ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
 }
 /** returns a JSON Path filter expression; e.g., `$.pet[(?name='spot')]` */
 function filterExpression(basePath, filterKey, filterValue) {
+    const value = typeof filterValue === 'number' ? filterValue : `'${filterValue}'`;
     return typeof filterKey === 'string' && filterKey.includes('.')
-        ? `${basePath}[?(@[${filterKey}]='${filterValue}')]`
-        : `${basePath}[?(@.${filterKey}='${filterValue}')]`;
+        ? `${basePath}[?(@[${filterKey}]==${value})]`
+        : `${basePath}[?(@.${filterKey}==${value})]`;
 }