object-diagram-js-differ 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,188 @@
+'use strict';
+
+var minDash = require('min-dash');
+var jsondiffpatch = require('jsondiffpatch');
+
+/* eslint no-cond-assign: 0 */
+
+function is(element, type) {
+  return element.$instanceOf(type);
+}
+
+function isAny(element, types) {
+  return types.some(function(t) {
+    return is(element, t);
+  });
+}
+
+function isTracked(element) {
+
+  const track = isAny(element, [
+    'od:OdBoard',
+    'od:Object',
+    'od:Link',
+  ]);
+
+  if (track) {
+    return {
+      element: element,
+      property: ''
+    };
+  }
+}
+
+function ChangeHandler() {
+  this._layoutChanged = {};
+  this._changed = {};
+  this._removed = {};
+  this._added = {};
+}
+
+
+ChangeHandler.prototype.removed = function(model, property, element, idx) {
+
+  let tracked;
+
+  if (tracked = isTracked(element)) {
+    if (!this._removed[tracked.element.id]) {
+      this._removed[tracked.element.id] = element;
+    }
+  } else
+
+    if (tracked = isTracked(model)) {
+      this.changed(tracked.element, tracked.property + property + '[' + idx + ']', null, element);
+    }
+};
+
+ChangeHandler.prototype.changed = function(model, property, newValue, oldValue) {
+
+  let tracked;
+
+  if (tracked = isTracked(model)) {
+    let changed = this._changed[tracked.element.id];
+
+    if (!changed) {
+      changed = this._changed[tracked.element.id] = { model: model, attrs: { } };
+    }
+
+    if (oldValue !== undefined || newValue !== undefined) {
+      changed.attrs[property] = { oldValue: oldValue, newValue: newValue };
+    }
+  }
+};
+
+ChangeHandler.prototype.added = function(model, property, element, idx) {
+
+  let tracked;
+
+  if (tracked = isTracked(element)) {
+    if (!this._added[tracked.element.id]) {
+      this._added[tracked.element.id] = element;
+    }
+  } else
+
+    if (tracked = isTracked(model)) {
+      this.changed(tracked.element, tracked.property + property + '[' + idx + ']', element, null);
+    }
+};
+
+ChangeHandler.prototype.moved = function(model, property, oldIndex, newIndex) {
+
+  // noop
+};
+
+function Differ() { }
+
+
+Differ.prototype.createDiff = function(a, b) {
+
+  // create a configured instance, match objects by name
+  const diffpatcher = new jsondiffpatch.DiffPatcher({
+    objectHash: function(obj) {
+      return obj.id || JSON.stringify(obj);
+    },
+    propertyFilter: function(name, context) {
+      return name !== '$instanceOf';
+    }
+  });
+
+  return diffpatcher.diff(a, b);
+};
+
+
+Differ.prototype.diff = function(a, b, handler) {
+
+  handler = handler || new ChangeHandler();
+
+  function walk(diff, model) {
+
+    minDash.forEach(diff, function(d, key) {
+
+      if (d._t !== 'a' && minDash.isArray(d)) {
+
+        // take into account that collection properties are lazily
+        // initialized; this means that adding to an empty collection
+        // looks like setting an undefined variable to []
+        //
+        // ensure we detect this case and change it to an array diff
+        if (minDash.isArray(d[0])) {
+
+          d = minDash.reduce(d[0], function(newDelta, element, idx) {
+            const prefix = d.length === 3 ? '_' : '';
+
+            newDelta[prefix + idx] = [ element ];
+
+            return newDelta;
+          }, { _t: 'a' });
+        }
+
+      }
+
+
+      // is array
+      if (d._t === 'a') {
+
+        minDash.forEach(d, function(val, idx) {
+
+          if (idx === '_t') {
+            return;
+          }
+
+          const removed = /^_/.test(idx),
+                added = !removed && minDash.isArray(val),
+                moved = removed && val[0] === '';
+
+          idx = parseInt(removed ? idx.slice(1) : idx, 10);
+
+          if (added || (removed && !moved)) {
+            handler[removed ? 'removed' : 'added'](model, key, val[0], idx);
+          } else
+            if (moved) {
+              handler.moved(model, key, val[1], val[2]);
+            } else {
+              walk(val, model[key][idx]);
+            }
+        });
+      } else {
+        if (minDash.isArray(d)) {
+          handler.changed(model, key, d[0], d[1]);
+        } else {
+          handler.changed(model, key);
+          walk(d, model[key]);
+        }
+      }
+    });
+  }
+
+  const diff = this.createDiff(a, b);
+
+  walk(diff, b);
+
+  return handler;
+};
+
+function diff(a, b, handler) {
+  return new Differ().diff(a, b, handler);
+}
+
+module.exports = diff;

package/dist/index.esm.js

@@ -0,0 +1,186 @@
+import { forEach, isArray, reduce } from 'min-dash';
+import { DiffPatcher } from 'jsondiffpatch';
+
+/* eslint no-cond-assign: 0 */
+
+function is(element, type) {
+  return element.$instanceOf(type);
+}
+
+function isAny(element, types) {
+  return types.some(function(t) {
+    return is(element, t);
+  });
+}
+
+function isTracked(element) {
+
+  const track = isAny(element, [
+    'od:OdBoard',
+    'od:Object',
+    'od:Link',
+  ]);
+
+  if (track) {
+    return {
+      element: element,
+      property: ''
+    };
+  }
+}
+
+function ChangeHandler() {
+  this._layoutChanged = {};
+  this._changed = {};
+  this._removed = {};
+  this._added = {};
+}
+
+
+ChangeHandler.prototype.removed = function(model, property, element, idx) {
+
+  let tracked;
+
+  if (tracked = isTracked(element)) {
+    if (!this._removed[tracked.element.id]) {
+      this._removed[tracked.element.id] = element;
+    }
+  } else
+
+    if (tracked = isTracked(model)) {
+      this.changed(tracked.element, tracked.property + property + '[' + idx + ']', null, element);
+    }
+};
+
+ChangeHandler.prototype.changed = function(model, property, newValue, oldValue) {
+
+  let tracked;
+
+  if (tracked = isTracked(model)) {
+    let changed = this._changed[tracked.element.id];
+
+    if (!changed) {
+      changed = this._changed[tracked.element.id] = { model: model, attrs: { } };
+    }
+
+    if (oldValue !== undefined || newValue !== undefined) {
+      changed.attrs[property] = { oldValue: oldValue, newValue: newValue };
+    }
+  }
+};
+
+ChangeHandler.prototype.added = function(model, property, element, idx) {
+
+  let tracked;
+
+  if (tracked = isTracked(element)) {
+    if (!this._added[tracked.element.id]) {
+      this._added[tracked.element.id] = element;
+    }
+  } else
+
+    if (tracked = isTracked(model)) {
+      this.changed(tracked.element, tracked.property + property + '[' + idx + ']', element, null);
+    }
+};
+
+ChangeHandler.prototype.moved = function(model, property, oldIndex, newIndex) {
+
+  // noop
+};
+
+function Differ() { }
+
+
+Differ.prototype.createDiff = function(a, b) {
+
+  // create a configured instance, match objects by name
+  const diffpatcher = new DiffPatcher({
+    objectHash: function(obj) {
+      return obj.id || JSON.stringify(obj);
+    },
+    propertyFilter: function(name, context) {
+      return name !== '$instanceOf';
+    }
+  });
+
+  return diffpatcher.diff(a, b);
+};
+
+
+Differ.prototype.diff = function(a, b, handler) {
+
+  handler = handler || new ChangeHandler();
+
+  function walk(diff, model) {
+
+    forEach(diff, function(d, key) {
+
+      if (d._t !== 'a' && isArray(d)) {
+
+        // take into account that collection properties are lazily
+        // initialized; this means that adding to an empty collection
+        // looks like setting an undefined variable to []
+        //
+        // ensure we detect this case and change it to an array diff
+        if (isArray(d[0])) {
+
+          d = reduce(d[0], function(newDelta, element, idx) {
+            const prefix = d.length === 3 ? '_' : '';
+
+            newDelta[prefix + idx] = [ element ];
+
+            return newDelta;
+          }, { _t: 'a' });
+        }
+
+      }
+
+
+      // is array
+      if (d._t === 'a') {
+
+        forEach(d, function(val, idx) {
+
+          if (idx === '_t') {
+            return;
+          }
+
+          const removed = /^_/.test(idx),
+                added = !removed && isArray(val),
+                moved = removed && val[0] === '';
+
+          idx = parseInt(removed ? idx.slice(1) : idx, 10);
+
+          if (added || (removed && !moved)) {
+            handler[removed ? 'removed' : 'added'](model, key, val[0], idx);
+          } else
+            if (moved) {
+              handler.moved(model, key, val[1], val[2]);
+            } else {
+              walk(val, model[key][idx]);
+            }
+        });
+      } else {
+        if (isArray(d)) {
+          handler.changed(model, key, d[0], d[1]);
+        } else {
+          handler.changed(model, key);
+          walk(d, model[key]);
+        }
+      }
+    });
+  }
+
+  const diff = this.createDiff(a, b);
+
+  walk(diff, b);
+
+  return handler;
+};
+
+function diff(a, b, handler) {
+  return new Differ().diff(a, b, handler);
+}
+
+export { diff as default };