json-diff-ts 1.2.7 → 1.2.8

package/lib/index.js

@@ -1,2 +1,18 @@
-export * from './jsonDiff';
-export * from './jsonCompare';
+"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);

package/lib/jsonCompare.js

@@ -1,58 +1,64 @@
-import { chain, keys, replace, set } from 'lodash';
-import { diff, flattenChangeset, getTypeOfObj, Operation } from './jsonDiff';
-export var CompareOperation;
+"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;
 (function (CompareOperation) {
     CompareOperation["CONTAINER"] = "CONTAINER";
     CompareOperation["UNCHANGED"] = "UNCHANGED";
-})(CompareOperation || (CompareOperation = {}));
-export const createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
-export const createContainer = (value) => ({
+})(CompareOperation = exports.CompareOperation || (exports.CompareOperation = {}));
+const createValue = (value) => ({ type: CompareOperation.UNCHANGED, value });
+exports.createValue = createValue;
+const createContainer = (value) => ({
     type: CompareOperation.CONTAINER,
     value
 });
-export const enrich = (object) => {
-    const objectType = getTypeOfObj(object);
+exports.createContainer = createContainer;
+const enrich = (object) => {
+    const objectType = (0, jsonDiff_1.getTypeOfObj)(object);
     switch (objectType) {
         case 'Object':
-            return keys(object)
-                .map((key) => ({ key, value: 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;
-            }, createContainer({}));
+            }, (0, exports.createContainer)({}));
         case 'Array':
-            return chain(object)
-                .map((value) => enrich(value))
+            return (0, lodash_1.chain)(object)
+                .map((value) => (0, exports.enrich)(value))
                 .reduce((accumulator, value) => {
                 accumulator.value.push(value);
                 return accumulator;
-            }, createContainer([]))
+            }, (0, exports.createContainer)([]))
                 .value();
         case 'Function':
             return undefined;
         case 'Date':
         default:
             // Primitive value
-            return createValue(object);
+            return (0, exports.createValue)(object);
     }
 };
-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.') })))
+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 Operation.ADD:
-            case Operation.UPDATE:
-                set(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
+            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 });
                 break;
-            case Operation.REMOVE:
-                set(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
+            case jsonDiff_1.Operation.REMOVE:
+                (0, lodash_1.set)(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });
                 break;
             default:
                 throw new Error();
@@ -60,6 +66,8 @@ export const applyChangelist = (object, changelist) => {
     });
     return object;
 };
-export const compare = (oldObject, newObject) => {
-    return applyChangelist(enrich(oldObject), flattenChangeset(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.js

@@ -1,5 +1,8 @@
-import { difference, find, intersection, keyBy } from 'lodash';
-export const getTypeOfObj = (obj) => {
+"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) => {
     if (typeof obj === 'undefined') {
         return 'undefined';
     }
@@ -8,14 +11,15 @@ export 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 = getTypeOfObj(oldObj);
-    const typeOfNewObj = 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 });
@@ -62,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 = 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]);
@@ -71,7 +75,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             changes = changes.concat(diffs);
         }
     }
-    const addedKeys = 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]);
@@ -81,7 +85,7 @@ const compareObject = (oldObj, newObj, path, embeddedObjKeys, keyPath, skipPath
             value: newObj[k]
         });
     }
-    const deletedKeys = 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]);
@@ -136,7 +140,7 @@ const convertArrayToObj = (arr, uniqKey) => {
         });
     }
     else if (uniqKey !== '$index') {
-        obj = keyBy(arr, uniqKey);
+        obj = (0, lodash_1.keyBy)(arr, uniqKey);
     }
     else {
         for (let i = 0; i < arr.length; i++) {
@@ -229,9 +233,9 @@ const applyArrayChange = (arr, change) => (() => {
                 }
             }
             else {
-                element = 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(applyChangeset(element, subchange.changes));
+            result.push((0, exports.applyChangeset)(element, subchange.changes));
         }
     }
     return result;
@@ -241,7 +245,7 @@ const applyBranchChange = (obj, change) => {
         return applyArrayChange(obj, change);
     }
     else {
-        return applyChangeset(obj, change.changes);
+        return (0, exports.applyChangeset)(obj, change.changes);
     }
 };
 const revertLeafChange = (obj, change, embeddedKey = '$index') => {
@@ -267,9 +271,9 @@ const revertArrayChange = (arr, change) => (() => {
                 element = arr[+subchange.key];
             }
             else {
-                element = find(arr, (el) => el[change.embeddedKey].toString() === subchange.key);
+                element = (0, lodash_1.find)(arr, (el) => el[change.embeddedKey].toString() === subchange.key);
             }
-            result.push(revertChangeset(element, subchange.changes));
+            result.push((0, exports.revertChangeset)(element, subchange.changes));
         }
     }
     return result;
@@ -279,11 +283,12 @@ const revertBranchChange = (obj, change) => {
         return revertArrayChange(obj, change);
     }
     else {
-        return revertChangeset(obj, change.changes);
+        return (0, exports.revertChangeset)(obj, change.changes);
     }
 };
-export const diff = (oldObj, newObj, embeddedObjKeys) => compare(oldObj, newObj, [], embeddedObjKeys, []);
-export const 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)
@@ -291,7 +296,8 @@ export const applyChangeset = (obj, changeset) => {
     }
     return obj;
 };
-export const revertChangeset = (obj, changeset) => {
+exports.applyChangeset = applyChangeset;
+const revertChangeset = (obj, changeset) => {
     if (changeset) {
         changeset
             .reverse()
@@ -299,15 +305,16 @@ export const revertChangeset = (obj, changeset) => {
     }
     return obj;
 };
-export var Operation;
+exports.revertChangeset = revertChangeset;
+var Operation;
 (function (Operation) {
     Operation["REMOVE"] = "REMOVE";
     Operation["ADD"] = "ADD";
     Operation["UPDATE"] = "UPDATE";
-})(Operation || (Operation = {}));
-export const flattenChangeset = (obj, path = '$', embeddedKey) => {
+})(Operation = exports.Operation || (exports.Operation = {}));
+const flattenChangeset = (obj, path = '$', embeddedKey) => {
     if (Array.isArray(obj)) {
-        return obj.reduce((memo, change) => [...memo, ...flattenChangeset(change, path, embeddedKey)], []);
+        return obj.reduce((memo, change) => [...memo, ...(0, exports.flattenChangeset)(change, path, embeddedKey)], []);
     }
     else {
         if (obj.changes || embeddedKey) {
@@ -317,7 +324,7 @@ export const flattenChangeset = (obj, path = '$', embeddedKey) => {
                 }
                 else if (embeddedKey === '$value') {
                     path = `${path}[?(@='${obj.key}')]`;
-                    const valueType = getTypeOfObj(obj.value);
+                    const valueType = (0, exports.getTypeOfObj)(obj.value);
                     return [
                         Object.assign(Object.assign({}, obj), { path,
                             valueType })
@@ -330,17 +337,18 @@ export const flattenChangeset = (obj, path = '$', embeddedKey) => {
             else {
                 path = `${path}.${obj.key}`;
             }
-            return flattenChangeset(obj.changes || obj, path, obj.embeddedKey);
+            return (0, exports.flattenChangeset)(obj.changes || obj, path, obj.embeddedKey);
         }
         else {
-            const valueType = 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 })
             ];
         }
     }
 };
-export const unflattenChanges = (changes) => {
+exports.flattenChangeset = flattenChangeset;
+const unflattenChanges = (changes) => {
     if (!Array.isArray(changes)) {
         changes = [changes];
     }
@@ -455,3 +463,4 @@ export const unflattenChanges = (changes) => {
     });
     return changesArr;
 };
+exports.unflattenChanges = unflattenChanges;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-diff-ts",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "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",