json-diff-ts 1.2.2 → 1.2.3

package/README.md

@@ -280,6 +280,7 @@ Twitter: [@cglessner](https://twitter.com/cglessner)
 
 ## Changelog
 
+- v1.2.3 Update outdated dependencies; update TypeScript version to 4.5.2
 - v1.2.2 Add support for functions to resove object keys (PR by [Abraxxa](https://github.com/abraxxa))
 
 ## Credits

package/lib/index.js

@@ -1,7 +1,14 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
-__export(require("./jsonDiff"));
-__export(require("./jsonCompare"));
+__exportStar(require("./jsonDiff"), exports);
+__exportStar(require("./jsonCompare"), exports);

package/lib/jsonCompare.js

@@ -1,5 +1,6 @@
 "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;
@@ -7,54 +8,57 @@ var CompareOperation;
     CompareOperation["CONTAINER"] = "CONTAINER";
     CompareOperation["UNCHANGED"] = "UNCHANGED";
 })(CompareOperation = exports.CompareOperation || (exports.CompareOperation = {}));
-exports.createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
-exports.createContainer = (value) => ({
+const createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
+exports.createValue = createValue;
+const createContainer = (value) => ({
     type: CompareOperation.CONTAINER,
     value
 });
-exports.enrich = (object) => {
-    const objectType = jsonDiff_1.getTypeOfObj(object);
+exports.createContainer = createContainer;
+const enrich = (object) => {
+    const objectType = (0, jsonDiff_1.getTypeOfObj)(object);
     switch (objectType) {
         case 'Object':
-            return lodash_1.keys(object)
-                .map((key) => ({ key, value: exports.enrich(object[key]) }))
+            return (0, lodash_1.keys)(object)
+                .map((key) => ({ key, value: (0, exports.enrich)(object[key]) }))
                 .reduce((accumulator, entry) => {
                 accumulator.value[entry.key] = entry.value;
                 return accumulator;
-            }, exports.createContainer({}));
+            }, (0, exports.createContainer)({}));
         case 'Array':
-            return lodash_1.chain(object)
-                .map(value => exports.enrich(value))
+            return (0, lodash_1.chain)(object)
+                .map(value => (0, exports.enrich)(value))
                 .reduce((accumulator, value) => {
                 accumulator.value.push(value);
                 return accumulator;
-            }, exports.createContainer([]))
+            }, (0, exports.createContainer)([]))
                 .value();
         case 'Function':
             return undefined;
         case 'Date':
         default:
             // Primitive value
-            return exports.createValue(object);
+            return (0, exports.createValue)(object);
     }
 };
-exports.applyChangelist = (object, changelist) => {
-    lodash_1.chain(changelist)
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, '$.', '.') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, /(\[(?<array>\d)\]\.)/g, 'ARRVAL_START$<array>ARRVAL_END') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, /(?<dot>\.)/g, '.value$<dot>') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, /\./, '') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, /ARRVAL_START/g, '.value[') })))
-        .map(entry => (Object.assign(Object.assign({}, entry), { path: lodash_1.replace(entry.path, /ARRVAL_END/g, '].value.') })))
+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.') })))
         .value()
         .forEach(entry => {
         switch (entry.type) {
             case jsonDiff_1.Operation.ADD:
             case jsonDiff_1.Operation.UPDATE:
-                lodash_1.set(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
+                (0, lodash_1.set)(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
                 break;
             case jsonDiff_1.Operation.REMOVE:
-                lodash_1.set(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
+                (0, lodash_1.set)(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
                 break;
             default:
                 throw new Error();
@@ -62,6 +66,8 @@ exports.applyChangelist = (object, changelist) => {
     });
     return object;
 };
-exports.compare = (oldObject, newObject) => {
-    return exports.applyChangelist(exports.enrich(oldObject), jsonDiff_1.flattenChangeset(jsonDiff_1.diff(oldObject, newObject)));
+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)));
 };
+exports.compare = compare;

package/lib/jsonDiff.d.ts

@@ -26,6 +26,6 @@ export interface IFlatChange {
     value?: any;
     oldValue?: any;
 }
-export declare const flattenChangeset: (obj: IChange | Changeset, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
+export declare const flattenChangeset: (obj: Changeset | IChange, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
 export declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) => IChange[];
 export {};

package/lib/jsonDiff.js

@@ -1,7 +1,8 @@
 "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");
-exports.getTypeOfObj = (obj) => {
+const getTypeOfObj = (obj) => {
     if (typeof obj === 'undefined') {
         return 'undefined';
     }
@@ -10,14 +11,15 @@ exports.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 = exports.getTypeOfObj(oldObj);
-    const typeOfNewObj = exports.getTypeOfObj(newObj);
+    const typeOfOldObj = (0, exports.getTypeOfObj)(oldObj);
+    const typeOfNewObj = (0, exports.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 });
@@ -64,7 +66,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
     let changes = [];
     const oldObjKeys = Object.keys(oldObj);
     const newObjKeys = Object.keys(newObj);
-    const intersectionKeys = lodash_1.intersection(oldObjKeys, newObjKeys);
+    const intersectionKeys = (0, lodash_1.intersection)(oldObjKeys, newObjKeys);
     for (k of intersectionKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -73,7 +75,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             changes = changes.concat(diffs);
         }
     }
-    const addedKeys = lodash_1.difference(newObjKeys, oldObjKeys);
+    const addedKeys = (0, lodash_1.difference)(newObjKeys, oldObjKeys);
     for (k of addedKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -83,7 +85,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             value: newObj[k]
         });
     }
-    const deletedKeys = lodash_1.difference(oldObjKeys, newObjKeys);
+    const deletedKeys = (0, lodash_1.difference)(oldObjKeys, newObjKeys);
     for (k of deletedKeys) {
         newPath = path.concat([k]);
         newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
@@ -133,7 +135,7 @@ const getObjectKey = (embeddedObjKeys, keyPath) => {
 const convertArrayToObj = (arr, uniqKey) => {
     let obj = {};
     if (uniqKey !== '$index') {
-        obj = lodash_1.keyBy(arr, uniqKey);
+        obj = (0, lodash_1.keyBy)(arr, uniqKey);
     }
     else {
         for (let i = 0; i < arr.length; i++) {
@@ -217,9 +219,9 @@ const applyArrayChange = (arr, change) => (() => {
                 element = arr[subchange.key];
             }
             else {
-                element = lodash_1.find(arr, el => el[change.embeddedKey].toString() === subchange.key.toString());
+                element = (0, lodash_1.find)(arr, el => el[change.embeddedKey].toString() === subchange.key.toString());
             }
-            result.push(exports.applyChangeset(element, subchange.changes));
+            result.push((0, exports.applyChangeset)(element, subchange.changes));
         }
     }
     return result;
@@ -229,7 +231,7 @@ const applyBranchChange = (obj, change) => {
         return applyArrayChange(obj, change);
     }
     else {
-        return exports.applyChangeset(obj, change.changes);
+        return (0, exports.applyChangeset)(obj, change.changes);
     }
 };
 const revertLeafChange = (obj, change, embeddedKey = '$index') => {
@@ -255,9 +257,9 @@ const revertArrayChange = (arr, change) => (() => {
                 element = arr[+subchange.key];
             }
             else {
-                element = lodash_1.find(arr, el => el[change.embeddedKey].toString() === subchange.key);
+                element = (0, lodash_1.find)(arr, el => el[change.embeddedKey].toString() === subchange.key);
             }
-            result.push(exports.revertChangeset(element, subchange.changes));
+            result.push((0, exports.revertChangeset)(element, subchange.changes));
         }
     }
     return result;
@@ -267,11 +269,12 @@ const revertBranchChange = (obj, change) => {
         return revertArrayChange(obj, change);
     }
     else {
-        return exports.revertChangeset(obj, change.changes);
+        return (0, exports.revertChangeset)(obj, change.changes);
     }
 };
-exports.diff = (oldObj, newObj, embeddedObjKeys) => compare(oldObj, newObj, [], embeddedObjKeys, []);
-exports.applyChangeset = (obj, changeset) => {
+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)
@@ -279,7 +282,8 @@ exports.applyChangeset = (obj, changeset) => {
     }
     return obj;
 };
-exports.revertChangeset = (obj, changeset) => {
+exports.applyChangeset = applyChangeset;
+const revertChangeset = (obj, changeset) => {
     if (changeset) {
         changeset
             .reverse()
@@ -287,15 +291,16 @@ exports.revertChangeset = (obj, changeset) => {
     }
     return obj;
 };
+exports.revertChangeset = revertChangeset;
 var Operation;
 (function (Operation) {
     Operation["REMOVE"] = "REMOVE";
     Operation["ADD"] = "ADD";
     Operation["UPDATE"] = "UPDATE";
 })(Operation = exports.Operation || (exports.Operation = {}));
-exports.flattenChangeset = (obj, path = '$', embeddedKey) => {
+const flattenChangeset = (obj, path = '$', embeddedKey) => {
     if (Array.isArray(obj)) {
-        return obj.reduce((memo, change) => [...memo, ...exports.flattenChangeset(change, path, embeddedKey)], []);
+        return obj.reduce((memo, change) => [...memo, ...(0, exports.flattenChangeset)(change, path, embeddedKey)], []);
     }
     else {
         if (obj.changes || embeddedKey) {
@@ -306,17 +311,18 @@ exports.flattenChangeset = (obj, path = '$', embeddedKey) => {
                         ? path
                         : `${path}[?(@.${embeddedKey}='${obj.key}')]`
                 : (path = `${path}.${obj.key}`);
-            return exports.flattenChangeset(obj.changes || obj, path, obj.embeddedKey);
+            return (0, exports.flattenChangeset)(obj.changes || obj, path, obj.embeddedKey);
         }
         else {
-            const valueType = exports.getTypeOfObj(obj.value);
+            const valueType = (0, exports.getTypeOfObj)(obj.value);
             return [
                 Object.assign(Object.assign({}, obj), { path: valueType === 'Object' || path.endsWith(`[${obj.key}]`) ? path : `${path}.${obj.key}`, valueType })
             ];
         }
     }
 };
-exports.unflattenChanges = (changes) => {
+exports.flattenChangeset = flattenChangeset;
+const unflattenChanges = (changes) => {
     if (!Array.isArray(changes)) {
         changes = [changes];
     }
@@ -431,3 +437,4 @@ exports.unflattenChanges = (changes) => {
     });
     return changesArr;
 };
+exports.unflattenChanges = unflattenChanges;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-diff-ts",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "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",
@@ -37,14 +37,14 @@
   },
   "homepage": "https://github.com/ltwlf/json-diff-ts#readme",
   "devDependencies": {
-    "@types/jest": "^24.0.23",
+    "@types/jest": "^27.0.3",
     "@types/lodash": "^4.14.149",
     "jest": "^24.9.0",
-    "prettier": "^1.19.1",
+    "prettier": "^2.5.1",
     "ts-jest": "^24.2.0",
-    "tslint": "^5.20.1",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typescript": "^3.7.2"
+    "typescript": "^4.5.2"
   },
   "peerDependencies": {
     "lodash": "^4.x"