Add simple array option and handle re order

README.md

@@ -18,9 +18,7 @@
 A small library that can deep diff two JavaScript Objects, including nested structures of arrays and objects.
 
 ## Installation
-`yarn add deep-object-diff`
-
-`npm i --save deep-object-diff`
+`yarn add awcjack/deep-object-diff#real-fix`
 
 ## Functions available:
  - [`diff(originalObj, updatedObj)`](#diff)
@@ -139,9 +137,13 @@ console.log(addedDiff(lhs, rhs));
  foo: {
  bar: {
  c: {
- '2': 'z'
+ '2': {
+ after: 'z'
+ }
  },
- d: 'Hello, world!'
+ d: {
+ after: 'Hello, world!'
+ }
  }
  }
 }
@@ -181,9 +183,13 @@ console.log(deletedDiff(lhs, rhs));
  foo: {
  bar: {
  a: {
- '1': undefined
+ '1': {
+ before: 'b'
+ }
  },
- e: undefined
+ e: {
+ before: 'Hello, world!'
+ }
  }
  }
 }
@@ -220,7 +226,10 @@ console.log(updatedDiff(lhs, rhs));
 
 /*
 {
- buzz: 'fizz'
+ buzz: {
+ before: 'world'
+ after: 'fizz'
+ }
 }
 */
 ```
@@ -259,24 +268,35 @@ console.log(detailedDiff(lhs, rhs));
  foo: {
  bar: {
  c: {
- '2': 'z'
+ '2': {
+ after: 'z'
+ }
  },
- d: 'Hello, world!'
+ d: {
+ after: 'Hello, world!'
+ }
  }
  }
  },
  deleted: {
  foo: {
  bar: {
  a: {
- '1': undefined
+ '1': {
+ before: 'b'
+ }
  },
- e: undefined
+ e: {
+ before: 100
+ }
  }
  }
  },
  updated: {
- buzz: 'fizz'
+ buzz: {
+ before: 'world'
+ after: 'fizz'
+ }
  }
 }
 */

dist/added/index.js

@@ -0,0 +1,121 @@
+(function (global, factory) {
+ if (typeof define === "function" && define.amd) {
+ define(["module", "exports", "lodash", "../utils"], factory);
+ } else if (typeof exports !== "undefined") {
+ factory(module, exports, require("lodash"), require("../utils"));
+ } else {
+ var mod = {
+ exports: {}
+ };
+ factory(mod, mod.exports, global.lodash, global.utils);
+ global.index = mod.exports;
+ }
+})(this, function (module, exports, _lodash, _utils) {
+ "use strict";
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ var _lodash2 = _interopRequireDefault(_lodash);
+
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : {
+ default: obj
+ };
+ }
+
+ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+ return typeof obj;
+ } : function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ };
+
+ function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ var _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ var addedDiff = function addedDiff(lhs, rhs) {
+
+ if (lhs === rhs || !(0, _utils.isObject)(lhs) || !(0, _utils.isObject)(rhs)) return {};
+
+ var l = (0, _utils.properObject)(lhs);
+ var r = (0, _utils.properObject)(rhs);
+
+ return Object.keys(r).reduce(function (acc, key) {
+ if (l.hasOwnProperty(key)) {
+ if (Array.isArray(l[key]) && Array.isArray(r[key])) {
+ //const allKeys = _.merge(l[key], r[key]) ?? []
+ var newFields = _lodash2.default.uniq(_lodash2.default.difference(r[key], l[key]));
+ if (newFields.length === 0) {
+ return acc;
+ }
+ var newFieldsIndex = _lodash2.default.map(newFields, function (o) {
+ return {
+ content: o,
+ index: []
+ };
+ });
+
+ var _loop = function _loop(i) {
+ var index = _lodash2.default.findIndex(newFields, function (o) {
+ return _lodash2.default.isEqual(o, r[key][i]);
+ });
+ if (index !== -1) {
+ newFieldsIndex[index].index.push(i);
+ }
+ };
+
+ for (var i = 0; i < r[key].length; i++) {
+ _loop(i);
+ }
+ return _extends({}, acc, _defineProperty({}, key, { after: newFieldsIndex }));
+ }
+ var difference = addedDiff(l[key], r[key]);
+
+ if ((0, _utils.isObject)(difference) && (0, _utils.isEmpty)(difference)) return acc;
+
+ return _extends({}, acc, _defineProperty({}, key, difference));
+ }
+ if (_typeof(r[key]) === "object" && l[key] === undefined) {
+ if (Array.isArray(r[key])) {
+ return _extends({}, acc, _defineProperty({}, key, { after: r[key] }));
+ }
+ var _difference = addedDiff({}, r[key]);
+ if ((0, _utils.isObject)(_difference) && (0, _utils.isEmpty)(_difference)) return acc;
+
+ return _extends({}, acc, _defineProperty({}, key, _difference));
+ }
+
+ return _extends({}, acc, _defineProperty({}, key, { after: r[key] }));
+ }, {});
+ };
+
+ exports.default = addedDiff;
+ module.exports = exports["default"];
+});

dist/arrayDiff/index.js

@@ -0,0 +1,101 @@
+(function (global, factory) {
+ if (typeof define === "function" && define.amd) {
+ define(['module', 'exports', '../utils'], factory);
+ } else if (typeof exports !== "undefined") {
+ factory(module, exports, require('../utils'));
+ } else {
+ var mod = {
+ exports: {}
+ };
+ factory(mod, mod.exports, global.utils);
+ global.index = mod.exports;
+ }
+})(this, function (module, exports, _utils) {
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ var _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ var diff = function diff(lhs, rhs) {
+ if (lhs === rhs) return {}; // equal return no diff
+
+ if (!(0, _utils.isObject)(lhs) || !(0, _utils.isObject)(rhs)) return rhs; // return updated rhs
+
+ var l = (0, _utils.properObject)(lhs);
+ var r = (0, _utils.properObject)(rhs);
+
+ var deletedValues = Object.keys(l).reduce(function (acc, key) {
+ return r.hasOwnProperty(key) ? acc : _extends({}, acc, _defineProperty({}, key, undefined));
+ }, {});
+
+ if ((0, _utils.isDate)(l) || (0, _utils.isDate)(r)) {
+ if (l.valueOf() == r.valueOf()) return {};
+ return r;
+ }
+
+ if (Array.isArray(r) && Array.isArray(l)) {
+ var _deletedValues = l.reduce(function (acc, item, index) {
+ return r.hasOwnProperty(index) ? acc.concat(item) : acc.concat(undefined);
+ }, []);
+
+ return r.reduce(function (acc, rightItem, index) {
+ if (!_deletedValues.hasOwnProperty(index)) {
+ return acc.concat(rightItem);
+ }
+
+ var leftItem = l[index];
+ var difference = diff(rightItem, leftItem);
+
+ if ((0, _utils.isObject)(difference) && (0, _utils.isEmpty)(difference) && !(0, _utils.isDate)(difference)) {
+ delete acc[index];
+ return acc; // return no diff
+ }
+
+ return acc.slice(0, index).concat(rightItem).concat(acc.slice(index + 1)); // return updated key
+ }, _deletedValues);
+ }
+
+ return Object.keys(r).reduce(function (acc, key) {
+ if (!l.hasOwnProperty(key)) return _extends({}, acc, _defineProperty({}, key, r[key])); // return added r key
+
+ var difference = diff(l[key], r[key]);
+
+ if ((0, _utils.isObject)(difference) && (0, _utils.isEmpty)(difference) && !(0, _utils.isDate)(difference)) return acc; // return no diff
+
+ return _extends({}, acc, _defineProperty({}, key, difference)); // return updated key
+ }, deletedValues);
+ };
+
+ exports.default = diff;
+ module.exports = exports['default'];
+});