npm - json-diff-ts - Versions diffs - 1.2.5 → 1.2.7 - Mend

json-diff-ts 1.2.5 → 1.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/lib/index.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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,38 +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
-                        : `${path}[?(@.${embeddedKey}='${obj.key}')]`
-                : (path = `${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 : `${path}.${obj.key}`, valueType })
             ];
         }
     }
 };
-exports.flattenChangeset = flattenChangeset;
-const unflattenChanges = (changes) => {
+export const unflattenChanges = (changes) => {
     if (!Array.isArray(changes)) {
         changes = [changes];
     }
@@ -354,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;
@@ -362,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 {
@@ -437,4 +455,3 @@ const unflattenChanges = (changes) => {
     });
     return changesArr;
 };
-exports.unflattenChanges = unflattenChanges;

package/package.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
   "name": "json-diff-ts",
-  "version": "1.2.5",
+  "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"
   }
-}
+}