json-diff-ts 2.0.0 → 2.2.0

package/README.md

@@ -33,7 +33,8 @@ const oldData = {
   characters: [
     { id: 'LUK', name: 'Luke Skywalker', force: true },
     { id: 'LEI', name: 'Leia Organa', force: true }
-  ]
+  ],
+  weapons: ['Lightsaber', 'Blaster']
 };
 
 const newData = {
@@ -42,7 +43,8 @@ const newData = {
   characters: [
     { id: 'LUK', name: 'Luke Skywalker', force: true, rank: 'Commander' },
     { id: 'HAN', name: 'Han Solo', force: false }
-  ]
+  ],
+  weapons: ['Lightsaber', 'Blaster', 'Bowcaster']
 };
 
 const diffs = diff(oldData, newData, { characters: 'id' });
@@ -116,7 +118,13 @@ const expectedDiffs = [
 Paths can be utilized to identify keys within nested arrays.
 
 ```javascript
-const diffs = diff(oldData, newData, { characters.subarray: 'id' });
+const diffs = diff(oldData, newData, { 'characters.subarray': 'id' });
+```
+
+You can also designate the root by using '.' instead of an empty string ('').
+
+```javascript
+const diffs = diff(oldData, newData, { '.characters.subarray': 'id' });
 ```
 
 You can use a function to dynamically resolve the key of the object.
@@ -138,6 +146,12 @@ embeddedObjKeys.set(/^char\w+$/, 'id'); // instead of 'id' you can specify a fun
 const diffs = diff(oldObj, newObj, embeddedObjKeys);
 ```
 
+Compare string arrays by value instead of index
+
+```javascript
+const diffs = diff(oldObj, newObj, { stringArr: '$value' });
+```
+
 ### `flattenChangeset`
 
 Transforms a complex changeset into a flat list of atomic changes, each describable by a JSONPath.
@@ -238,6 +252,8 @@ Discover more about the company behind this project: [hololux](https://hololux.c
 
 ## Release Notes
 
+- **v2.2.0:** Fix lodash-es decependency, exclude keys, compare string arrays by value
+- **v2.1.0:** Resolves a problem related to JSON Path filters by replacing the single equal sign (=) with a double equal sign (==). This update maintains compatibility with existing flat changes. Allows to use either '' or '.' as root in the path.
 - **v2.0.0:** json-diff-ts has been upgraded to an ECMAScript module! This major update brings optimizations and enhanced documentation. Additionally, a previously existing issue where all paths were treated as regex has been fixed. In this new version, you'll need to use a Map instead of a Record for regex paths. Please note that this is a breaking change if you were using regex paths in the previous versions.
 - **v1.2.6:** Enhanced JSON Path handling for period-inclusive segments.
 - **v1.2.5:** Patched dependencies; added key name resolution support for key functions.

package/lib/jsonDiff.d.ts

@@ -23,7 +23,15 @@ export interface IFlatChange {
     value?: any;
     oldValue?: any;
 }
-export declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType): IChange[];
+/**
+ * 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, keysToSkip?: string[]): IChange[];
 /**
  * Applies all changes in the changeset to the object.
  *

package/lib/jsonDiff.js

@@ -5,8 +5,27 @@ export var Operation;
     Operation["ADD"] = "ADD";
     Operation["UPDATE"] = "UPDATE";
 })(Operation || (Operation = {}));
-export function diff(oldObj, newObj, embeddedObjKeys) {
-    return compare(oldObj, newObj, [], embeddedObjKeys, []);
+/**
+ * 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, keysToSkip) {
+    // 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, [], keysToSkip);
 }
 /**
  * Applies all changes in the changeset to the object.
@@ -73,13 +92,31 @@ export const flattenChangeset = (obj, 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));
+            if (embeddedKey) {
+                if (embeddedKey === '$index') {
+                    path = `${path}[${obj.key}]`;
+                }
+                else if (embeddedKey === '$value') {
+                    path = `${path}[?(@='${obj.key}')]`;
+                    const valueType = getTypeOfObj(obj.value);
+                    return [
+                        {
+                            ...obj,
+                            path,
+                            valueType
+                        }
+                    ];
+                }
+                else if (obj.type === Operation.ADD) {
+                    // do nothing
+                }
+                else {
+                    path = filterExpression(path, embeddedKey, obj.key);
+                }
+            }
+            else {
+                path = append(path, obj.key);
+            }
             return flattenChangeset(obj.changes || obj, path, obj.embeddedKey);
         }
         else {
@@ -115,14 +152,7 @@ export const unflattenChanges = (changes) => {
     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;
-        }, []);
+        const segments = change.path.split(/(?<=[^@])\.(?=[^@])/);
         if (segments.length === 1) {
             ptr.key = change.key;
             ptr.type = change.type;
@@ -133,8 +163,8 @@ export const unflattenChanges = (changes) => {
         else {
             for (let i = 1; i < segments.length; i++) {
                 const segment = segments[i];
-                // Matches JSONPath segments: "items[?(@.id='123')]" or "items[2]"
-                const result = /^(.+)\[\?\(@\.(.+)='(.+)'\)]$|^(.+)\[(\d+)\]/.exec(segment);
+                // Matches JSONPath segments: "items[?(@.id=='123')]", "items[?(@.id==123)]", "items[2]", "items[?(@='123')]"
+                const result = /^(.+?)\[\?\(@.?(?:([^=]*))?={1,2}'(.*)'\)\]$|^(.+?)\[(\d+)\]$/.exec(segment); //NOSONAR
                 // array
                 if (result) {
                     let key;
@@ -142,13 +172,13 @@ export const unflattenChanges = (changes) => {
                     let arrKey;
                     if (result[1]) {
                         key = result[1];
-                        embeddedKey = result[2];
+                        embeddedKey = result[2] || '$value';
                         arrKey = result[3];
                     }
                     else {
                         key = result[4];
                         embeddedKey = '$index';
-                        arrKey = Number(result[5]);
+                        arrKey = Number(result[4]);
                     }
                     // leaf
                     if (i === segments.length - 1) {
@@ -241,7 +271,7 @@ const getKey = (path) => {
     const left = path[path.length - 1];
     return left != null ? left : '$root';
 };
-const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
+const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath, keysToSkip) => {
     let changes = [];
     const typeOfOldObj = getTypeOfObj(oldObj);
     const typeOfNewObj = getTypeOfObj(newObj);
@@ -260,7 +290,7 @@ const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
             })));
             break;
         case 'Object':
-            const diffs = compareObject(oldObj, newObj, path, embeddedObjKeys, keyPath);
+            const diffs = compareObject(oldObj, newObj, path, embeddedObjKeys, keyPath, false, keysToSkip);
             if (diffs.length) {
                 if (path.length) {
                     changes.push({
@@ -275,7 +305,7 @@ const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
             }
             break;
         case 'Array':
-            changes = changes.concat(compareArray(oldObj, newObj, path, embeddedObjKeys, keyPath));
+            changes = changes.concat(compareArray(oldObj, newObj, path, embeddedObjKeys, keyPath, keysToSkip));
             break;
         case 'Function':
             break;
@@ -285,7 +315,7 @@ const compare = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
     }
     return changes;
 };
-const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath = false) => {
+const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath = false, keysToSkip = []) => {
     let k;
     let newKeyPath;
     let newPath;
@@ -293,13 +323,13 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
         skipPath = false;
     }
     let changes = [];
-    const oldObjKeys = Object.keys(oldObj);
-    const newObjKeys = Object.keys(newObj);
+    const oldObjKeys = Object.keys(oldObj).filter((key) => keysToSkip.indexOf(key) === -1);
+    const newObjKeys = Object.keys(newObj).filter((key) => keysToSkip.indexOf(key) === -1);
     const intersectionKeys = intersection(oldObjKeys, newObjKeys);
     for (k of intersectionKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
-        const diffs = compare(oldObj[k], newObj[k], newPath, embeddedObjKeys, newKeyPath);
+        const diffs = compare(oldObj[k], newObj[k], newPath, embeddedObjKeys, newKeyPath, keysToSkip);
         if (diffs.length) {
             changes = changes.concat(diffs);
         }
@@ -326,12 +356,12 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
     }
     return changes;
 };
-const compareArray = (oldObj, newObj, path, embeddedObjKeys, keyPath) => {
+const compareArray = (oldObj, newObj, path, embeddedObjKeys, keyPath, keysToSkip) => {
     const left = getObjectKey(embeddedObjKeys, keyPath);
     const uniqKey = left != null ? left : '$index';
     const indexedOldObj = convertArrayToObj(oldObj, uniqKey);
     const indexedNewObj = convertArrayToObj(newObj, uniqKey);
-    const diffs = compareObject(indexedOldObj, indexedNewObj, path, embeddedObjKeys, keyPath, true);
+    const diffs = compareObject(indexedOldObj, indexedNewObj, path, embeddedObjKeys, keyPath, true, keysToSkip);
     if (diffs.length) {
         return [
             {
@@ -370,7 +400,12 @@ const getObjectKey = (embeddedObjKeys, keyPath) => {
 };
 const convertArrayToObj = (arr, uniqKey) => {
     let obj = {};
-    if (uniqKey !== '$index') {
+    if (uniqKey === '$value') {
+        arr.forEach((value) => {
+            obj[value] = value;
+        });
+    }
+    else if (uniqKey !== '$index') {
         obj = keyBy(arr, uniqKey);
     }
     else {
@@ -414,6 +449,9 @@ const removeKey = (obj, key, embeddedKey) => {
     }
 };
 const indexOfItemInArray = (arr, key, value) => {
+    if (key === '$value') {
+        return arr.indexOf(value);
+    }
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
         if (item && item[key] ? item[key].toString() === value.toString() : undefined) {
@@ -453,8 +491,14 @@ const applyArrayChange = (arr, change) => (() => {
             if (change.embeddedKey === '$index') {
                 element = arr[subchange.key];
             }
+            else if (change.embeddedKey === '$value') {
+                const index = arr.indexOf(subchange.key);
+                if (index !== -1) {
+                    element = arr[index];
+                }
+            }
             else {
-                element = find(arr, (el) => el[change.embeddedKey].toString() === subchange.key.toString());
+                element = find(arr, (el) => el[change.embeddedKey]?.toString() === subchange.key.toString());
             }
             result.push(applyChangeset(element, subchange.changes));
         }
@@ -513,7 +557,8 @@ function append(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})]`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-diff-ts",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "A JSON diff tool for JavaScript written in TypeScript.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -9,8 +9,8 @@
     "build": "tsc",
     "format": "prettier --write \"src/**/*.ts\"",
     "lint": "eslint 'src/**/*.ts'",
-    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --config jest.config.mjs",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules npx jest --watch --config jest.config.mjs",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.mjs",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --config jest.config.mjs",
     "prepare": "npm run build",
     "prepublishOnly": "npm test && npm run lint",
     "preversion": "npm run lint",
@@ -37,15 +37,17 @@
     "url": "https://github.com/ltwlf/json-diff-ts/issues"
   },
   "homepage": "https://github.com/ltwlf/json-diff-ts#readme",
+  "dependencies": {
+    "lodash-es": "^4.17.21"
+  },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
     "@types/jest": "^29.5.7",
     "@types/lodash-es": "^4.17.10",
     "eslint": "^8.53.0",
-    "jest": "^29.5.0",
-    "lodash-es": "^4.17.21",
+    "jest": "^29.7.0",
     "prettier": "^3.0.3",
     "ts-jest": "^29.0.5",
-    "typescript": "^4.9.5"
+    "typescript": "^5.3.2"
   }
 }