json-diff-ts 1.2.6 → 1.2.7

package/README.md

@@ -281,7 +281,7 @@ Blog: https://blog.leitwolf.io
 Twitter: [@cglessner](https://twitter.com/cglessner)
 
 ## Changelog
-- v1.2.6 Improve handling of JSON Path segments that include periods (PR by [EdVinyard](https://github.com/EdVinyard))
+
 - v1.2.5 Patch all dependencies; add support for resolving a key name if a function is used to get the key value
 - v1.2.4 Fix readme (npm install); update TypeScript and Lodash
 - v1.2.3 Update outdated dependencies; update TypeScript version to 4.5.2

package/lib/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./jsonDiff"), exports);
-__exportStar(require("./jsonCompare"), exports);
+export * from './jsonDiff';
+export * from './jsonCompare';

package/lib/jsonCompare.js

@@ -1,64 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compare = exports.applyChangelist = exports.enrich = exports.createContainer = exports.createValue = exports.CompareOperation = void 0;
-const lodash_1 = require("lodash");
-const jsonDiff_1 = require("./jsonDiff");
-var CompareOperation;
+import { chain, keys, replace, set } from 'lodash';
+import { diff, flattenChangeset, getTypeOfObj, Operation } from './jsonDiff';
+export var CompareOperation;
 (function (CompareOperation) {
     CompareOperation["CONTAINER"] = "CONTAINER";
     CompareOperation["UNCHANGED"] = "UNCHANGED";
-})(CompareOperation = exports.CompareOperation || (exports.CompareOperation = {}));
-const createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
-exports.createValue = createValue;
-const createContainer = (value) => ({
+})(CompareOperation || (CompareOperation = {}));
+export const createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
+export const createContainer = (value) => ({
     type: CompareOperation.CONTAINER,
     value
 });
-exports.createContainer = createContainer;
-const enrich = (object) => {
-    const objectType = (0, jsonDiff_1.getTypeOfObj)(object);
+export const enrich = (object) => {
+    const objectType = getTypeOfObj(object);
     switch (objectType) {
         case 'Object':
-            return (0, lodash_1.keys)(object)
-                .map((key) => ({ key, value: (0, exports.enrich)(object[key]) }))
+            return keys(object)
+                .map((key) => ({ key, value: enrich(object[key]) }))
                 .reduce((accumulator, entry) => {
                 accumulator.value[entry.key] = entry.value;
                 return accumulator;
-            }, (0, exports.createContainer)({}));
+            }, createContainer({}));
         case 'Array':
-            return (0, lodash_1.chain)(object)
-                .map(value => (0, exports.enrich)(value))
+            return chain(object)
+                .map((value) => enrich(value))
                 .reduce((accumulator, value) => {
                 accumulator.value.push(value);
                 return accumulator;
-            }, (0, exports.createContainer)([]))
+            }, createContainer([]))
                 .value();
         case 'Function':
             return undefined;
         case 'Date':
         default:
             // Primitive value
-            return (0, exports.createValue)(object);
+            return createValue(object);
     }
 };
-exports.enrich = enrich;
-const applyChangelist = (object, changelist) => {
-    (0, lodash_1.chain)(changelist)
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, '$.', '.') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, /(\[(?<array>\d)\]\.)/g, 'ARRVAL_START$<array>ARRVAL_END') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, /(?<dot>\.)/g, '.value$<dot>') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, /\./, '') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, /ARRVAL_START/g, '.value[') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: (0, lodash_1.replace)(entry.path, /ARRVAL_END/g, '].value.') })))
+export const applyChangelist = (object, changelist) => {
+    chain(changelist)
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, '$.', '.') })))
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, /(\[(?<array>\d)\]\.)/g, 'ARRVAL_START$<array>ARRVAL_END') })))
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, /(?<dot>\.)/g, '.value$<dot>') })))
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, /\./, '') })))
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, /ARRVAL_START/g, '.value[') })))
+        .map((entry) => (Object.assign(Object.assign({}, entry), { path: replace(entry.path, /ARRVAL_END/g, '].value.') })))
         .value()
-        .forEach(entry => {
+        .forEach((entry) => {
         switch (entry.type) {
-            case jsonDiff_1.Operation.ADD:
-            case jsonDiff_1.Operation.UPDATE:
-                (0, lodash_1.set)(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
+            case Operation.ADD:
+            case Operation.UPDATE:
+                set(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
                 break;
-            case jsonDiff_1.Operation.REMOVE:
-                (0, lodash_1.set)(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
+            case Operation.REMOVE:
+                set(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
                 break;
             default:
                 throw new Error();
@@ -66,8 +60,6 @@ const applyChangelist = (object, changelist) => {
     });
     return object;
 };
-exports.applyChangelist = applyChangelist;
-const compare = (oldObject, newObject) => {
-    return (0, exports.applyChangelist)((0, exports.enrich)(oldObject), (0, jsonDiff_1.flattenChangeset)((0, jsonDiff_1.diff)(oldObject, newObject)));
+export const compare = (oldObject, newObject) => {
+    return applyChangelist(enrich(oldObject), flattenChangeset(diff(oldObject, newObject)));
 };
-exports.compare = compare;

package/lib/jsonDiff.d.ts

@@ -1,7 +1,6 @@
-import { Dictionary } from 'lodash';
-declare type FunctionKey = (obj: any, getKeyName?: boolean) => any;
+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 diff: (oldObj: any, newObj: any, embeddedObjKeys?: Record<string, string | FunctionKey>) => IChange[];
 export declare const applyChangeset: (obj: any, changeset: Changeset) => any;
 export declare const revertChangeset: (obj: any, changeset: Changeset) => any;
 export declare enum Operation {
@@ -17,7 +16,7 @@ export interface IChange {
     oldValue?: any;
     changes?: IChange[];
 }
-export declare type Changeset = IChange[];
+export type Changeset = IChange[];
 export interface IFlatChange {
     type: Operation;
     key: string;

package/lib/jsonDiff.js

@@ -1,8 +1,5 @@
-"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';
+export const getTypeOfObj = (obj) => {
     if (typeof obj === 'undefined') {
         return 'undefined';
     }
@@ -11,15 +8,14 @@ const getTypeOfObj = (obj) => {
     }
     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 });
@@ -66,7 +62,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 +71,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 +81,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]);
@@ -134,8 +130,13 @@ const getObjectKey = (embeddedObjKeys, keyPath) => {
 };
 const convertArrayToObj = (arr, uniqKey) => {
     let obj = {};
-    if (uniqKey !== '$index') {
-        obj = (0, lodash_1.keyBy)(arr, uniqKey);
+    if (uniqKey === '$value') {
+        arr.forEach((value) => {
+            obj[value] = value;
+        });
+    }
+    else if (uniqKey !== '$index') {
+        obj = keyBy(arr, uniqKey);
     }
     else {
         for (let i = 0; i < arr.length; i++) {
@@ -179,6 +180,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) {
@@ -218,10 +222,16 @@ 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 = (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 +241,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 +267,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,12 +279,11 @@ const revertBranchChange = (obj, change) => {
         return revertArrayChange(obj, change);
     }
     else {
-        return (0, exports.revertChangeset)(obj, change.changes);
+        return revertChangeset(obj, change.changes);
     }
 };
-const diff = (oldObj, newObj, embeddedObjKeys) => compare(oldObj, newObj, [], embeddedObjKeys, []);
-exports.diff = diff;
-const applyChangeset = (obj, changeset) => {
+export const diff = (oldObj, newObj, embeddedObjKeys) => compare(oldObj, newObj, [], embeddedObjKeys, []);
+export const applyChangeset = (obj, changeset) => {
     if (changeset) {
         changeset.forEach((change) => (change.value !== null && change.value !== undefined) || change.type === Operation.REMOVE
             ? applyLeafChange(obj, change, change.embeddedKey)
@@ -282,8 +291,7 @@ const applyChangeset = (obj, changeset) => {
     }
     return obj;
 };
-exports.applyChangeset = applyChangeset;
-const revertChangeset = (obj, changeset) => {
+export const revertChangeset = (obj, changeset) => {
     if (changeset) {
         changeset
             .reverse()
@@ -291,40 +299,48 @@ const revertChangeset = (obj, changeset) => {
     }
     return obj;
 };
-exports.revertChangeset = revertChangeset;
-var Operation;
+export var Operation;
 (function (Operation) {
     Operation["REMOVE"] = "REMOVE";
     Operation["ADD"] = "ADD";
     Operation["UPDATE"] = "UPDATE";
-})(Operation = exports.Operation || (exports.Operation = {}));
-const flattenChangeset = (obj, path = '$', embeddedKey) => {
+})(Operation || (Operation = {}));
+export const flattenChangeset = (obj, path = '$', embeddedKey) => {
     if (Array.isArray(obj)) {
-        return obj.reduce((memo, change) => [...memo, ...(0, exports.flattenChangeset)(change, path, embeddedKey)], []);
+        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 (0, exports.flattenChangeset)(obj.changes || obj, path, obj.embeddedKey);
+            if (embeddedKey) {
+                if (embeddedKey === '$index') {
+                    path = `${path}[${obj.key}]`;
+                }
+                else if (embeddedKey === '$value') {
+                    path = `${path}[?(@='${obj.key}')]`;
+                    const valueType = getTypeOfObj(obj.value);
+                    return [
+                        Object.assign(Object.assign({}, obj), { path,
+                            valueType })
+                    ];
+                }
+                else if (obj.type !== Operation.ADD) {
+                    path = `${path}[?(@.${embeddedKey}='${obj.key}')]`;
+                }
+            }
+            else {
+                path = `${path}.${obj.key}`;
+            }
+            return flattenChangeset(obj.changes || obj, path, obj.embeddedKey);
         }
         else {
-            const valueType = (0, exports.getTypeOfObj)(obj.value);
+            const valueType = getTypeOfObj(obj.value);
             return [
-                Object.assign(Object.assign({}, obj), { path: valueType === 'Object' || path.endsWith(`[${obj.key}]`)
-                        ? path
-                        : append(path, obj.key), valueType })
+                Object.assign(Object.assign({}, obj), { path: valueType === 'Object' || path.endsWith(`[${obj.key}]`) ? path : `${path}.${obj.key}`, valueType })
             ];
         }
     }
 };
-exports.flattenChangeset = flattenChangeset;
-const unflattenChanges = (changes) => {
+export const unflattenChanges = (changes) => {
     if (!Array.isArray(changes)) {
         changes = [changes];
     }
@@ -356,7 +372,7 @@ const unflattenChanges = (changes) => {
             for (let i = 1; i < segments.length; i++) {
                 const segment = segments[i];
                 // check for array
-                const result = /^(.+)\[\?\(@\.(.+)='(.+)'\)]$|^(.+)\[(\d+)\]/.exec(segment);
+                const result = /^(.+)\[\?\(@\.?(.{0,})='(.+)'\)]$|^(.+)\[(\d+)\]/.exec(segment);
                 // array
                 if (result) {
                     let key;
@@ -364,7 +380,7 @@ const unflattenChanges = (changes) => {
                     let arrKey;
                     if (result[1]) {
                         key = result[1];
-                        embeddedKey = result[2];
+                        embeddedKey = result[2] || '$value';
                         arrKey = result[3];
                     }
                     else {
@@ -439,16 +455,3 @@ const unflattenChanges = (changes) => {
     });
     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}`;
-}
-/** returns a JSON Path filter expression; e.g., `$.pet[(?name='spot')]` */
-function filterExpression(basePath, filterKey, filterValue) {
-    return typeof filterKey === 'string' && filterKey.includes('.')
-        ? `${basePath}[?(@[${filterKey}]='${filterValue}')]`
-        : `${basePath}[?(@.${filterKey}='${filterValue}')]`;
-}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "json-diff-ts",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "A diff tool for JavaScript based on https://www.npmjs.com/package/diff-json written in TypeScript.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "format": "prettier --write \"src/**/*.ts\"",
     "lint": "tslint -p tsconfig.json",
     "test": "jest --config jest.config.json",
     "test:watch": "jest --watch --config jest.config.json",
@@ -38,15 +38,15 @@
   "homepage": "https://github.com/ltwlf/json-diff-ts#readme",
   "devDependencies": {
     "@types/jest": "^29.1.1",
-    "@types/lodash": "^4.14.149",
-    "jest": "^24.9.0",
+    "@types/lodash-es": "^4.14.149",
+    "jest": "^29.5.0",
     "prettier": "^2.5.1",
-    "ts-jest": "^24.2.0",
+    "ts-jest": "^29.0.5",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
     "typescript": "^4.5.2"
   },
-  "peerDependencies": {
-    "lodash": "^4.x"
+  "dependencies": {
+    "lodash": "^4.17.21"
   }
-}
+}