immutable-ops - npm Package Compare versions

Comparing version 0.5.2 to 0.6.0

lib/index.js

@@ -1,51 +0,28 @@
-'use strict';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-exports.ops = exports.getBatchToken = undefined;
-
-var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
-
-var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
-
-var _assign = require('babel-runtime/core-js/object/assign');
-
-var _assign2 = _interopRequireDefault(_assign);
-
-var _defineProperty = require('babel-runtime/core-js/object/define-property');
-
-var _defineProperty2 = _interopRequireDefault(_defineProperty);
-
-var _symbol = require('babel-runtime/core-js/symbol');
-
-var _symbol2 = _interopRequireDefault(_symbol);
-
-var _typeof2 = require('babel-runtime/helpers/typeof');
-
-var _typeof3 = _interopRequireDefault(_typeof2);
-
 exports.canMutate = canMutate;
 exports.getImmutableOps = getImmutableOps;
+exports.default = exports.ops = exports.getBatchToken = void 0;
 
-var _curry = require('ramda/src/curry');
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var _curry2 = _interopRequireDefault(_curry);
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-var _ = require('ramda/src/__');
+var _ramda = require("ramda");
 
-var _2 = _interopRequireDefault(_);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function forOwn(obj, fn) {
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            fn(obj[key], key);
-        }
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      fn(obj[key], key);
     }
+  }
 }
 
 function isArrayLike(value) {
-    return value && (typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object' && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;
+  return value && (0, _typeof2.default)(value) === 'object' && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;
 }
@@ -56,44 +33,47 @@
 function fastArrayCopy(arr) {
-    var copied = new Array(arr.length);
-    for (var i = 0; i < arr.length; i++) {
-        copied[i] = arr[i];
-    }
-    return copied;
+  var copied = new Array(arr.length);
+
+  for (var i = 0; i < arr.length; i++) {
+    copied[i] = arr[i];
+  }
+
+  return copied;
 }
 
 function canMutate(obj, ownerID) {
-    if (!ownerID) return false;
-    return obj[OWNER_ID_TAG] === ownerID;
+  if (!ownerID) return false;
+  return obj[OWNER_ID_TAG] === ownerID;
 }
 
-var newOwnerID = typeof _symbol2.default === 'function' ? function () {
-    return (0, _symbol2.default)('ownerID');
+var newOwnerID = typeof Symbol === 'function' ? function () {
+  return Symbol('ownerID');
 } : function () {
-    return {};
+  return {};
 };
+var getBatchToken = newOwnerID;
+exports.getBatchToken = getBatchToken;
 
-var getBatchToken = exports.getBatchToken = newOwnerID;
-
 function addOwnerID(obj, ownerID) {
-    (0, _defineProperty2.default)(obj, OWNER_ID_TAG, {
-        value: ownerID,
-        configurable: true,
-        enumerable: false
-    });
-
-    return obj;
+  Object.defineProperty(obj, OWNER_ID_TAG, {
+    value: ownerID,
+    configurable: true,
+    enumerable: false
+  });
+  return obj;
 }
 
 function prepareNewObject(instance, ownerID) {
-    if (ownerID) {
-        addOwnerID(instance, ownerID);
-    }
-    return instance;
+  if (ownerID) {
+    addOwnerID(instance, ownerID);
+  }
+
+  return instance;
 }
 
 function forceArray(arg) {
-    if (!(arg instanceof Array)) {
-        return [arg];
-    }
-    return arg;
+  if (!(arg instanceof Array)) {
+    return [arg];
+  }
+
+  return arg;
 }
@@ -104,146 +84,148 @@
 function normalizePath(pathArg) {
-    if (typeof pathArg === 'string') {
-        if (pathArg.indexOf(PATH_SEPARATOR) === -1) {
-            return [pathArg];
-        }
-        return pathArg.split(PATH_SEPARATOR);
+  if (typeof pathArg === 'string') {
+    if (pathArg.indexOf(PATH_SEPARATOR) === -1) {
+      return [pathArg];
     }
 
-    return pathArg;
+    return pathArg.split(PATH_SEPARATOR);
+  }
+
+  return pathArg;
 }
 
 function mutableSet(key, value, obj) {
-    obj[key] = value;
-    return obj;
+  obj[key] = value;
+  return obj;
 }
 
 function mutableSetIn(_pathArg, value, obj) {
-    var originalPathArg = normalizePath(_pathArg);
+  var originalPathArg = normalizePath(_pathArg);
+  var pathLen = originalPathArg.length;
+  var done = false;
+  var idx = 0;
+  var acc = obj;
+  var curr = originalPathArg[idx];
 
-    var pathLen = originalPathArg.length;
+  while (!done) {
+    if (idx === pathLen - 1) {
+      acc[curr] = value;
+      done = true;
+    } else {
+      var currType = (0, _typeof2.default)(acc[curr]);
 
-    var done = false;
-    var idx = 0;
-    var acc = obj;
-    var curr = originalPathArg[idx];
+      if (currType === 'undefined') {
+        var newObj = {};
+        prepareNewObject(newObj, null);
+        acc[curr] = newObj;
+      } else if (currType !== 'object') {
+        var pathRepr = "".concat(originalPathArg[idx - 1], ".").concat(curr);
+        throw new Error("A non-object value was encountered when traversing setIn path at ".concat(pathRepr, "."));
+      }
 
-    while (!done) {
-        if (idx === pathLen - 1) {
-            acc[curr] = value;
-            done = true;
-        } else {
-            var currType = (0, _typeof3.default)(acc[curr]);
-
-            if (currType === 'undefined') {
-                var newObj = {};
-                prepareNewObject(newObj, null);
-                acc[curr] = newObj;
-            } else if (currType !== 'object') {
-                var pathRepr = originalPathArg[idx - 1] + '.' + curr;
-                throw new Error('A non-object value was encountered when traversing setIn path at ' + pathRepr + '.');
-            }
-            acc = acc[curr];
-            idx++;
-            curr = originalPathArg[idx];
-        }
+      acc = acc[curr];
+      idx++;
+      curr = originalPathArg[idx];
     }
+  }
 
-    return obj;
+  return obj;
 }
 
 function valueInPath(_pathArg, obj) {
-    var pathArg = normalizePath(_pathArg);
+  var pathArg = normalizePath(_pathArg);
+  var acc = obj;
 
-    var acc = obj;
-    for (var i = 0; i < pathArg.length; i++) {
-        var curr = pathArg[i];
-        var currRef = acc[curr];
-        if (i === pathArg.length - 1) {
-            return currRef;
-        }
+  for (var i = 0; i < pathArg.length; i++) {
+    var curr = pathArg[i];
+    var currRef = acc[curr];
 
-        if ((typeof currRef === 'undefined' ? 'undefined' : (0, _typeof3.default)(currRef)) === 'object') {
-            acc = currRef;
-        } else {
-            return undefined;
-        }
+    if (i === pathArg.length - 1) {
+      return currRef;
     }
+
+    if ((0, _typeof2.default)(currRef) === 'object') {
+      acc = currRef;
+    } else {
+      return undefined;
+    }
+  }
+
+  return undefined;
 }
 
 function immutableSetIn(ownerID, _pathArg, value, obj) {
-    var pathArg = normalizePath(_pathArg);
+  var pathArg = normalizePath(_pathArg);
+  var currentValue = valueInPath(pathArg, obj);
+  if (value === currentValue) return obj;
+  var pathLen = pathArg.length;
+  var acc;
 
-    var currentValue = valueInPath(pathArg, obj);
-    if (value === currentValue) return obj;
+  if (canMutate(obj, ownerID)) {
+    acc = obj;
+  } else {
+    acc = Object.assign(prepareNewObject({}, ownerID), obj);
+  }
 
-    var pathLen = pathArg.length;
-
-    var acc = void 0;
-    if (canMutate(obj, ownerID)) {
-        acc = obj;
-    } else {
-        acc = (0, _assign2.default)(prepareNewObject({}, ownerID), obj);
+  var rootObj = acc;
+  pathArg.forEach(function (curr, idx) {
+    if (idx === pathLen - 1) {
+      acc[curr] = value;
+      return;
     }
 
-    var rootObj = acc;
+    var currRef = acc[curr];
+    var currType = (0, _typeof2.default)(currRef);
 
-    pathArg.forEach(function (curr, idx) {
-        if (idx === pathLen - 1) {
-            acc[curr] = value;
-            return;
-        }
+    if (currType === 'object') {
+      if (canMutate(currRef, ownerID)) {
+        acc = currRef;
+      } else {
+        var newObj = prepareNewObject({}, ownerID);
+        acc[curr] = Object.assign(newObj, currRef);
+        acc = newObj;
+      }
 
-        var currRef = acc[curr];
-        var currType = typeof currRef === 'undefined' ? 'undefined' : (0, _typeof3.default)(currRef);
+      return;
+    }
 
-        if (currType === 'object') {
-            if (canMutate(currRef, ownerID)) {
-                acc = currRef;
-            } else {
-                var newObj = prepareNewObject({}, ownerID);
-                acc[curr] = (0, _assign2.default)(newObj, currRef);
-                acc = newObj;
-            }
-            return;
-        }
+    if (currType === 'undefined') {
+      var _newObj = prepareNewObject({}, ownerID);
 
-        if (currType === 'undefined') {
-            var _newObj = prepareNewObject({}, ownerID);
-            acc[curr] = _newObj;
-            acc = _newObj;
-            return;
-        }
+      acc[curr] = _newObj;
+      acc = _newObj;
+      return;
+    }
 
-        var pathRepr = pathArg[idx - 1] + '.' + curr;
-        throw new Error('A non-object value was encountered when traversing setIn path at ' + pathRepr + '.');
-    });
-
-    return rootObj;
+    var pathRepr = "".concat(pathArg[idx - 1], ".").concat(curr);
+    throw new Error("A non-object value was encountered when traversing setIn path at ".concat(pathRepr, "."));
+  });
+  return rootObj;
 }
 
 function mutableMerge(isDeep, _mergeObjs, baseObj) {
-    var mergeObjs = forceArray(_mergeObjs);
+  var mergeObjs = forceArray(_mergeObjs);
 
-    if (isDeep) {
-        mergeObjs.forEach(function (mergeObj) {
-            forOwn(mergeObj, function (value, key) {
-                if (isDeep && baseObj.hasOwnProperty(key)) {
-                    var assignValue = void 0;
-                    if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object') {
-                        assignValue = mutableMerge(isDeep, [value], baseObj[key]);
-                    } else {
-                        assignValue = value;
-                    }
+  if (isDeep) {
+    mergeObjs.forEach(function (mergeObj) {
+      forOwn(mergeObj, function (value, key) {
+        if (isDeep && baseObj.hasOwnProperty(key)) {
+          var assignValue;
 
-                    baseObj[key] = assignValue;
-                } else {
-                    baseObj[key] = value;
-                }
-            });
-        });
-    } else {
-        _assign2.default.apply(Object, [baseObj].concat((0, _toConsumableArray3.default)(mergeObjs)));
-    }
+          if ((0, _typeof2.default)(value) === 'object') {
+            assignValue = mutableMerge(isDeep, [value], baseObj[key]);
+          } else {
+            assignValue = value;
+          }
 
-    return baseObj;
+          baseObj[key] = assignValue;
+        } else {
+          baseObj[key] = value;
+        }
+      });
+    });
+  } else {
+    Object.assign.apply(Object, [baseObj].concat((0, _toConsumableArray2.default)(mergeObjs)));
+  }
+
+  return baseObj;
 }
@@ -255,52 +237,55 @@
 function mutableOmit(_keys, obj) {
-    var keys = forceArray(_keys);
-    keys.forEach(function (key) {
-        delete obj[key];
-    });
-    return obj;
+  var keys = forceArray(_keys);
+  keys.forEach(function (key) {
+    delete obj[key];
+  });
+  return obj;
 }
 
-function _shouldMergeKey(obj, other, key) {
-    return obj[key] !== other[key];
+function shouldMergeKey(obj, other, key) {
+  return obj[key] !== other[key];
 }
 
 function immutableMerge(isDeep, ownerID, _mergeObjs, obj) {
-    if (canMutate(obj, ownerID)) return mutableMerge(isDeep, _mergeObjs, obj);
-    var mergeObjs = forceArray(_mergeObjs);
+  if (canMutate(obj, ownerID)) return mutableMerge(isDeep, _mergeObjs, obj);
+  var mergeObjs = forceArray(_mergeObjs);
+  var hasChanges = false;
+  var nextObject = obj;
 
-    var hasChanges = false;
-    var nextObject = obj;
+  var willChange = function willChange() {
+    if (!hasChanges) {
+      hasChanges = true;
+      nextObject = Object.assign({}, obj);
+      prepareNewObject(nextObject, ownerID);
+    }
+  };
 
-    var willChange = function willChange() {
-        if (!hasChanges) {
-            hasChanges = true;
-            nextObject = (0, _assign2.default)({}, obj);
-            prepareNewObject(nextObject, ownerID);
+  mergeObjs.forEach(function (mergeObj) {
+    forOwn(mergeObj, function (mergeValue, key) {
+      if (isDeep && obj.hasOwnProperty(key)) {
+        var currentValue = nextObject[key];
+
+        if ((0, _typeof2.default)(mergeValue) === 'object' && !(mergeValue instanceof Array)) {
+          if (shouldMergeKey(nextObject, mergeObj, key)) {
+            var recursiveMergeResult = immutableMerge(isDeep, ownerID, mergeValue, currentValue);
+
+            if (recursiveMergeResult !== currentValue) {
+              willChange();
+              nextObject[key] = recursiveMergeResult;
+            }
+          }
+
+          return true; // continue forOwn
         }
-    };
+      }
 
-    mergeObjs.forEach(function (mergeObj) {
-        forOwn(mergeObj, function (mergeValue, key) {
-            if (isDeep && obj.hasOwnProperty(key)) {
-                var currentValue = nextObject[key];
-                if ((typeof mergeValue === 'undefined' ? 'undefined' : (0, _typeof3.default)(mergeValue)) === 'object' && !(mergeValue instanceof Array)) {
-                    if (_shouldMergeKey(nextObject, mergeObj, key)) {
-                        var recursiveMergeResult = immutableMerge(isDeep, ownerID, mergeValue, currentValue);
+      if (shouldMergeKey(nextObject, mergeObj, key)) {
+        willChange();
+        nextObject[key] = mergeValue;
+      }
 
-                        if (recursiveMergeResult !== currentValue) {
-                            willChange();
-                            nextObject[key] = recursiveMergeResult;
-                        }
-                    }
-                    return true; // continue forOwn
-                }
-            }
-            if (_shouldMergeKey(nextObject, mergeObj, key)) {
-                willChange();
-                nextObject[key] = mergeValue;
-            }
-        });
+      return undefined;
     });
-
-    return nextObject;
+  });
+  return nextObject;
 }
@@ -312,186 +297,171 @@
 function immutableArrSet(ownerID, index, value, arr) {
-    if (canMutate(arr, ownerID)) return mutableSet(index, value, arr);
-
-    if (arr[index] === value) return arr;
-
-    var newArr = fastArrayCopy(arr);
-    newArr[index] = value;
-    prepareNewObject(newArr, ownerID);
-
-    return newArr;
+  if (canMutate(arr, ownerID)) return mutableSet(index, value, arr);
+  if (arr[index] === value) return arr;
+  var newArr = fastArrayCopy(arr);
+  newArr[index] = value;
+  prepareNewObject(newArr, ownerID);
+  return newArr;
 }
 
 function immutableSet(ownerID, key, value, obj) {
-    if (isArrayLike(obj)) return immutableArrSet(ownerID, key, value, obj);
-    if (canMutate(obj, ownerID)) return mutableSet(key, value, obj);
-
-    if (obj[key] === value) return obj;
-
-    var newObj = (0, _assign2.default)({}, obj);
-    prepareNewObject(newObj, ownerID);
-    newObj[key] = value;
-    return newObj;
+  if (isArrayLike(obj)) return immutableArrSet(ownerID, key, value, obj);
+  if (canMutate(obj, ownerID)) return mutableSet(key, value, obj);
+  if (obj[key] === value) return obj;
+  var newObj = Object.assign({}, obj);
+  prepareNewObject(newObj, ownerID);
+  newObj[key] = value;
+  return newObj;
 }
 
 function immutableOmit(ownerID, _keys, obj) {
-    if (canMutate(obj, ownerID)) return mutableOmit(_keys, obj);
+  if (canMutate(obj, ownerID)) return mutableOmit(_keys, obj);
+  var keys = forceArray(_keys);
+  var keysInObj = keys.filter(function (key) {
+    return obj.hasOwnProperty(key);
+  }); // None of the keys were in the object, so we can return `obj`.
 
-    var keys = forceArray(_keys);
-    var keysInObj = keys.filter(function (key) {
-        return obj.hasOwnProperty(key);
-    });
-
-    // None of the keys were in the object, so we can return `obj`.
-    if (keysInObj.length === 0) return obj;
-
-    var newObj = (0, _assign2.default)({}, obj);
-    keysInObj.forEach(function (key) {
-        delete newObj[key];
-    });
-    prepareNewObject(newObj, ownerID);
-    return newObj;
+  if (keysInObj.length === 0) return obj;
+  var newObj = Object.assign({}, obj);
+  keysInObj.forEach(function (key) {
+    delete newObj[key];
+  });
+  prepareNewObject(newObj, ownerID);
+  return newObj;
 }
 
 function mutableArrPush(_vals, arr) {
-    var vals = forceArray(_vals);
-    arr.push.apply(arr, (0, _toConsumableArray3.default)(vals));
-    return arr;
+  var vals = forceArray(_vals);
+  arr.push.apply(arr, (0, _toConsumableArray2.default)(vals));
+  return arr;
 }
 
 function mutableArrFilter(func, arr) {
-    var currIndex = 0;
-    var originalIndex = 0;
-    while (currIndex < arr.length) {
-        var item = arr[currIndex];
-        if (!func(item, originalIndex)) {
-            arr.splice(currIndex, 1);
-        } else {
-            currIndex++;
-        }
-        originalIndex++;
+  var currIndex = 0;
+  var originalIndex = 0;
+
+  while (currIndex < arr.length) {
+    var item = arr[currIndex];
+
+    if (!func(item, originalIndex)) {
+      arr.splice(currIndex, 1);
+    } else {
+      currIndex++;
     }
 
-    return arr;
+    originalIndex++;
+  }
+
+  return arr;
 }
 
 function mutableArrSplice(index, deleteCount, _vals, arr) {
-    var vals = forceArray(_vals);
-    arr.splice.apply(arr, [index, deleteCount].concat((0, _toConsumableArray3.default)(vals)));
-    return arr;
+  var vals = forceArray(_vals);
+  arr.splice.apply(arr, [index, deleteCount].concat((0, _toConsumableArray2.default)(vals)));
+  return arr;
 }
 
 function mutableArrInsert(index, _vals, arr) {
-    return mutableArrSplice(index, 0, _vals, arr);
+  return mutableArrSplice(index, 0, _vals, arr);
 }
 
 function immutableArrSplice(ownerID, index, deleteCount, _vals, arr) {
-    if (canMutate(arr, ownerID)) return mutableArrSplice(index, deleteCount, _vals, arr);
-
-    var vals = forceArray(_vals);
-    var newArr = arr.slice();
-    prepareNewObject(newArr, ownerID);
-    newArr.splice.apply(newArr, [index, deleteCount].concat((0, _toConsumableArray3.default)(vals)));
-
-    return newArr;
+  if (canMutate(arr, ownerID)) return mutableArrSplice(index, deleteCount, _vals, arr);
+  var vals = forceArray(_vals);
+  var newArr = arr.slice();
+  prepareNewObject(newArr, ownerID);
+  newArr.splice.apply(newArr, [index, deleteCount].concat((0, _toConsumableArray2.default)(vals)));
+  return newArr;
 }
 
 function immutableArrInsert(ownerID, index, _vals, arr) {
-    if (canMutate(arr, ownerID)) return mutableArrInsert(index, _vals, arr);
-    return immutableArrSplice(ownerID, index, 0, _vals, arr);
+  if (canMutate(arr, ownerID)) return mutableArrInsert(index, _vals, arr);
+  return immutableArrSplice(ownerID, index, 0, _vals, arr);
 }
 
 function immutableArrPush(ownerID, vals, arr) {
-    return immutableArrInsert(ownerID, arr.length, vals, arr);
+  return immutableArrInsert(ownerID, arr.length, vals, arr);
 }
 
 function immutableArrFilter(ownerID, func, arr) {
-    if (canMutate(arr, ownerID)) return mutableArrFilter(func, arr);
-    var newArr = arr.filter(func);
-
-    if (newArr.length === arr.length) return arr;
-
-    prepareNewObject(newArr, ownerID);
-    return newArr;
+  if (canMutate(arr, ownerID)) return mutableArrFilter(func, arr);
+  var newArr = arr.filter(func);
+  if (newArr.length === arr.length) return arr;
+  prepareNewObject(newArr, ownerID);
+  return newArr;
 }
 
 var immutableOperations = {
-    // object operations
-    merge: immutableShallowMerge,
-    deepMerge: immutableDeepMerge,
-    omit: immutableOmit,
-    setIn: immutableSetIn,
-
-    // array operations
-    insert: immutableArrInsert,
-    push: immutableArrPush,
-    filter: immutableArrFilter,
-    splice: immutableArrSplice,
-
-    // both
-    set: immutableSet
+  // object operations
+  merge: immutableShallowMerge,
+  deepMerge: immutableDeepMerge,
+  omit: immutableOmit,
+  setIn: immutableSetIn,
+  // array operations
+  insert: immutableArrInsert,
+  push: immutableArrPush,
+  filter: immutableArrFilter,
+  splice: immutableArrSplice,
+  // both
+  set: immutableSet
 };
-
 var mutableOperations = {
-    // object operations
-    merge: mutableShallowMerge,
-    deepMerge: mutableDeepMerge,
-    omit: mutableOmit,
-    setIn: mutableSetIn,
-
-    // array operations
-    insert: mutableArrInsert,
-    push: mutableArrPush,
-    filter: mutableArrFilter,
-    splice: mutableArrSplice,
-
-    // both
-    set: mutableSet
+  // object operations
+  merge: mutableShallowMerge,
+  deepMerge: mutableDeepMerge,
+  omit: mutableOmit,
+  setIn: mutableSetIn,
+  // array operations
+  insert: mutableArrInsert,
+  push: mutableArrPush,
+  filter: mutableArrFilter,
+  splice: mutableArrSplice,
+  // both
+  set: mutableSet
 };
 
 function getImmutableOps() {
-    var immutableOps = (0, _assign2.default)({}, immutableOperations);
-    forOwn(immutableOps, function (value, key) {
-        immutableOps[key] = (0, _curry2.default)(value.bind(null, null));
-    });
+  var immutableOps = Object.assign({}, immutableOperations);
+  forOwn(immutableOps, function (value, key) {
+    immutableOps[key] = (0, _ramda.curry)(value.bind(null, null));
+  });
+  var mutableOps = Object.assign({}, mutableOperations);
+  forOwn(mutableOps, function (value, key) {
+    mutableOps[key] = (0, _ramda.curry)(value);
+  });
+  var batchOps = Object.assign({}, immutableOperations);
+  forOwn(batchOps, function (value, key) {
+    batchOps[key] = (0, _ramda.curry)(value);
+  });
 
-    var mutableOps = (0, _assign2.default)({}, mutableOperations);
-    forOwn(mutableOps, function (value, key) {
-        mutableOps[key] = (0, _curry2.default)(value);
-    });
+  function batched(_token, _fn) {
+    var token;
+    var fn;
 
-    var batchOps = (0, _assign2.default)({}, immutableOperations);
-    forOwn(batchOps, function (value, key) {
-        batchOps[key] = (0, _curry2.default)(value);
-    });
-
-    function batched(_token, _fn) {
-        var token = void 0;
-        var fn = void 0;
-
-        if (typeof _token === 'function') {
-            fn = _token;
-            token = getBatchToken();
-        } else {
-            token = _token;
-            fn = _fn;
-        }
-
-        var immutableOpsBoundToToken = (0, _assign2.default)({}, immutableOperations);
-        forOwn(immutableOpsBoundToToken, function (value, key) {
-            immutableOpsBoundToToken[key] = (0, _curry2.default)(value.bind(null, token));
-        });
-        return fn(immutableOpsBoundToToken);
+    if (typeof _token === 'function') {
+      fn = _token;
+      token = getBatchToken();
+    } else {
+      token = _token;
+      fn = _fn;
     }
 
-    return (0, _assign2.default)(immutableOps, {
-        mutable: mutableOps,
-        batch: batchOps,
-        batched: batched,
-        __: _2.default,
-        getBatchToken: getBatchToken
+    var immutableOpsBoundToToken = Object.assign({}, immutableOperations);
+    forOwn(immutableOpsBoundToToken, function (value, key) {
+      immutableOpsBoundToToken[key] = (0, _ramda.curry)(value.bind(null, token));
     });
+    return fn(immutableOpsBoundToToken);
+  }
+
+  return Object.assign(immutableOps, {
+    mutable: mutableOps,
+    batch: batchOps,
+    batched: batched,
+    __: _ramda.__,
+    getBatchToken: getBatchToken
+  });
 }
 
-var ops = exports.ops = getImmutableOps();
-
-exports.default = ops;
+var ops = getImmutableOps();
+exports.ops = ops;
+var _default = ops;
+exports.default = _default;

lib/test/testOperations.js

@@ -1,491 +0,438 @@
-'use strict';
+"use strict";
 
-var _chai = require('chai');
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _chai2 = _interopRequireDefault(_chai);
+var _chai = _interopRequireDefault(require("chai"));
 
-var _sinonChai = require('sinon-chai');
+var _sinonChai = _interopRequireDefault(require("sinon-chai"));
 
-var _sinonChai2 = _interopRequireDefault(_sinonChai);
+var _deepFreeze = _interopRequireDefault(require("deep-freeze"));
 
-var _deepFreeze = require('deep-freeze');
+var _index = require("../index");
 
-var _deepFreeze2 = _interopRequireDefault(_deepFreeze);
+_chai.default.use(_sinonChai.default);
 
-var _index = require('../index');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-_chai2.default.use(_sinonChai2.default);
-var expect = _chai2.default.expect;
-
-
+var expect = _chai.default.expect;
 describe('batched', function () {
-    it('works', function () {
-        var res = _index.ops.batched(function (batchOps) {
-            var obj = {};
-            var result = batchOps.set('a', 1, obj);
-            expect(result).to.deep.equal({ a: 1 });
-            expect(result).not.to.equal(obj);
+  it('works', function () {
+    var res = _index.ops.batched(function (batchOps) {
+      var obj = {};
+      var result = batchOps.set('a', 1, obj);
+      expect(result).to.deep.equal({
+        a: 1
+      });
+      expect(result).not.to.equal(obj);
+      var result2 = batchOps.omit('a', result);
+      expect(result2).to.equal(result);
+      expect(result2).to.deep.equal({});
+      return result2;
+    });
 
-            var result2 = batchOps.omit('a', result);
-            expect(result2).to.equal(result);
-            expect(result2).to.deep.equal({});
-            return result2;
-        });
-
-        expect(res).to.deep.equal({});
-    });
+    expect(res).to.deep.equal({});
+  });
 });
-
 describe('operations', function () {
-    describe('object', function () {
-        describe('batched mutations', function () {
-            var token = (0, _index.getBatchToken)();
-            it('deepMerges', function () {
-                var baseObj = (0, _deepFreeze2.default)({
-                    change: 'Tommi',
-                    dontChange: 25,
-                    deeper: {
-                        dontChange: 'John',
-                        change: 30
-                    }
-                });
-                var mergeObj = (0, _deepFreeze2.default)({
-                    change: 'None',
-                    add: 'US',
-                    deeper: {
-                        add: 'US',
-                        change: 35
-                    }
-                });
-                var merger = _index.ops.batch.deepMerge(token, mergeObj);
-                var result = merger(baseObj);
-                expect((0, _index.canMutate)(result, token)).to.be.true;
-                expect((0, _index.canMutate)(result.deeper, token)).to.be.true;
+  describe('object', function () {
+    describe('batched mutations', function () {
+      var token = (0, _index.getBatchToken)();
+      it('deepMerges', function () {
+        var baseObj = (0, _deepFreeze.default)({
+          change: 'Tommi',
+          dontChange: 25,
+          deeper: {
+            dontChange: 'John',
+            change: 30
+          }
+        });
+        var mergeObj = (0, _deepFreeze.default)({
+          change: 'None',
+          add: 'US',
+          deeper: {
+            add: 'US',
+            change: 35
+          }
+        });
 
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-                expect((0, _index.canMutate)(result.deeper, (0, _index.getBatchToken)())).to.be.false;
+        var merger = _index.ops.batch.deepMerge(token, mergeObj);
 
-                expect(result).to.not.equal(baseObj);
+        var result = merger(baseObj);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect((0, _index.canMutate)(result.deeper, token)).to.be.true;
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
+        expect((0, _index.canMutate)(result.deeper, (0, _index.getBatchToken)())).to.be.false;
+        expect(result).to.not.equal(baseObj);
+        expect(result).to.contain.all.keys(['change', 'dontChange', 'add', 'deeper']);
+        expect(result.change).to.not.equal(baseObj.change);
+        expect(result.dontChange).to.equal(baseObj.dontChange);
+        expect(result.deeper).to.not.equal(baseObj.deeper);
+        expect(result.deeper).to.contain.all.keys(['dontChange', 'change', 'add']);
+        expect(result.deeper.dontChange).to.equal(baseObj.deeper.dontChange);
+        expect(result.deeper.change).to.not.equal(baseObj.deeper.change);
+      });
+      it('omits a single key', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-                expect(result).to.contain.all.keys(['change', 'dontChange', 'add', 'deeper']);
-                expect(result.change).to.not.equal(baseObj.change);
-                expect(result.dontChange).to.equal(baseObj.dontChange);
+        var omitter = _index.ops.batch.omit(token, 'age');
 
-                expect(result.deeper).to.not.equal(baseObj.deeper);
-                expect(result.deeper).to.contain.all.keys(['dontChange', 'change', 'add']);
-                expect(result.deeper.dontChange).to.equal(baseObj.deeper.dontChange);
-                expect(result.deeper.change).to.not.equal(baseObj.deeper.change);
-            });
+        var result = omitter(obj);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
+        expect(result).to.not.contain.keys(['age']); // Further modification should mutate the existing object.
 
-            it('omits a single key', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
+        expect(_index.ops.batch.omit(token, 'name', result)).to.equal(result);
+      });
+      it('omits an array of keys', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-                var omitter = _index.ops.batch.omit(token, 'age');
+        var omitter = _index.ops.batch.omit(token, ['age']);
 
-                var result = omitter(obj);
-                expect((0, _index.canMutate)(result, token)).to.be.true;
+        var result = omitter(obj);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
+        expect(result).to.not.contain.keys(['age']); // Further modification should mutate the existing object.
 
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-                expect(result).to.not.contain.keys(['age']);
+        expect(_index.ops.batch.omit(token, ['name'], result)).to.equal(result);
+      });
+      it('sets a value', function () {
+        var obj = (0, _deepFreeze.default)({
+          one: 1,
+          two: 500,
+          three: 3
+        });
 
-                // Further modification should mutate the existing object.
-                expect(_index.ops.batch.omit(token, 'name', result)).to.equal(result);
-            });
+        var result = _index.ops.batch.set(token, 'two', 5, obj);
 
-            it('omits an array of keys', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
+        expect((0, _index.canMutate)(result, token)).to.be.true;
 
-                var omitter = _index.ops.batch.omit(token, ['age']);
-                var result = omitter(obj);
+        var result2 = _index.ops.batch.set(token, 'two', 2, result);
 
-                expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect(result2).to.deep.equal({
+          one: 1,
+          two: 2,
+          three: 3
+        });
+        expect(result).to.equal(result2);
+      });
+      it('sets a value in path', function () {
+        var obj = (0, _deepFreeze.default)({
+          first: {
+            second: {
+              value: 'value',
+              maintain: true
+            },
+            maintain: true
+          },
+          maintain: true
+        });
 
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-                expect(result).to.not.contain.keys(['age']);
+        var setter = _index.ops.batch.setIn(token, 'first.second.value', 'anotherValue');
 
-                // Further modification should mutate the existing object.
-                expect(_index.ops.batch.omit(token, ['name'], result)).to.equal(result);
-            });
+        var result = setter(obj);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
+        expect(result).not.to.equal(obj);
+        expect(result.first.second.value).to.equal('anotherValue');
+        expect(result.maintain).to.be.true;
+        expect(result.first.maintain).to.be.true;
+        expect(result.first.second.maintain).to.be.true;
 
-            it('sets a value', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    one: 1,
-                    two: 500,
-                    three: 3
-                });
+        var result2 = _index.ops.batch.setIn(token, 'first.second.value', 'secondAnotherValue', result);
 
-                var result = _index.ops.batch.set(token, 'two', 5, obj);
+        expect(result).to.equal(result2);
+        expect(result2.first.second.value).to.equal('secondAnotherValue');
+      });
+    });
+    describe('immutable ops', function () {
+      it('deepMerges', function () {
+        var baseObj = (0, _deepFreeze.default)({
+          change: 'Tommi',
+          dontChange: 25,
+          deeper: {
+            dontChange: 'John',
+            change: 30
+          }
+        });
+        var mergeObj = (0, _deepFreeze.default)({
+          change: 'None',
+          add: 'US',
+          deeper: {
+            add: 'US',
+            change: 35
+          }
+        });
 
-                expect((0, _index.canMutate)(result, token)).to.be.true;
-                var result2 = _index.ops.batch.set(token, 'two', 2, result);
-                expect(result2).to.deep.equal({
-                    one: 1,
-                    two: 2,
-                    three: 3
-                });
+        var merger = _index.ops.deepMerge(mergeObj);
 
-                expect(result).to.equal(result2);
-            });
+        var result = merger(baseObj);
+        expect((0, _index.canMutate)(result)).to.be.false;
+        expect((0, _index.canMutate)(result.deeper)).to.be.false;
+        expect(result).to.not.equal(baseObj);
+        expect(result).to.contain.all.keys(['change', 'dontChange', 'add', 'deeper']);
+        expect(result.change).to.not.equal(baseObj.change);
+        expect(result.dontChange).to.equal(baseObj.dontChange);
+        expect(result.deeper).to.not.equal(baseObj.deeper);
+        expect(result.deeper).to.contain.all.keys(['dontChange', 'change', 'add']);
+        expect(result.deeper.dontChange).to.equal(baseObj.deeper.dontChange);
+        expect(result.deeper.change).to.not.equal(baseObj.deeper.change);
+      });
+      it('deepMerges and returns initial object when no values changed', function () {
+        var baseObj = (0, _deepFreeze.default)({
+          deep: {
+            dontChange: 'John'
+          }
+        });
+        var mergeObj = (0, _deepFreeze.default)({
+          deep: {
+            dontChange: 'John'
+          }
+        });
 
-            it('sets a value in path', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    first: {
-                        second: {
-                            value: 'value',
-                            maintain: true
-                        },
-                        maintain: true
-                    },
-                    maintain: true
-                });
+        var result = _index.ops.deepMerge(mergeObj, baseObj);
 
-                var setter = _index.ops.batch.setIn(token, 'first.second.value', 'anotherValue');
+        expect(result).to.equal(baseObj);
+      });
+      it('omits a single key', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-                var result = setter(obj);
-                expect((0, _index.canMutate)(result, token)).to.be.true;
+        var omitter = _index.ops.omit('age');
 
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-                expect(result).not.to.equal(obj);
-                expect(result.first.second.value).to.equal('anotherValue');
-                expect(result.maintain).to.be.true;
-                expect(result.first.maintain).to.be.true;
-                expect(result.first.second.maintain).to.be.true;
-
-                var result2 = _index.ops.batch.setIn(token, 'first.second.value', 'secondAnotherValue', result);
-                expect(result).to.equal(result2);
-                expect(result2.first.second.value).to.equal('secondAnotherValue');
-            });
+        var result = omitter(obj);
+        expect((0, _index.canMutate)(result)).to.be.false;
+        expect(result).to.not.contain.keys(['age']);
+      });
+      it('omits a single key, returns same object if no value changes', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
         });
 
-        describe('immutable ops', function () {
-            it('deepMerges', function () {
-                var baseObj = (0, _deepFreeze2.default)({
-                    change: 'Tommi',
-                    dontChange: 25,
-                    deeper: {
-                        dontChange: 'John',
-                        change: 30
-                    }
-                });
-                var mergeObj = (0, _deepFreeze2.default)({
-                    change: 'None',
-                    add: 'US',
-                    deeper: {
-                        add: 'US',
-                        change: 35
-                    }
-                });
+        var result = _index.ops.omit('location', obj);
 
-                var merger = _index.ops.deepMerge(mergeObj);
-                var result = merger(baseObj);
+        expect(result).to.equal(obj);
+      });
+      it('omits an array of keys', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-                expect((0, _index.canMutate)(result)).to.be.false;
-                expect((0, _index.canMutate)(result.deeper)).to.be.false;
+        var omitter = _index.ops.omit(['age']);
 
-                expect(result).to.not.equal(baseObj);
+        var result = omitter(obj);
+        expect((0, _index.canMutate)(result)).to.be.false;
+        expect(result).to.not.contain.keys(['age']);
+      });
+      it('sets a value', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-                expect(result).to.contain.all.keys(['change', 'dontChange', 'add', 'deeper']);
-                expect(result.change).to.not.equal(baseObj.change);
-                expect(result.dontChange).to.equal(baseObj.dontChange);
+        var result = _index.ops.set('age', 26, obj);
 
-                expect(result.deeper).to.not.equal(baseObj.deeper);
-                expect(result.deeper).to.contain.all.keys(['dontChange', 'change', 'add']);
-                expect(result.deeper.dontChange).to.equal(baseObj.deeper.dontChange);
-                expect(result.deeper.change).to.not.equal(baseObj.deeper.change);
-            });
+        expect(result).to.deep.equal({
+          name: 'Tommi',
+          age: 26
+        });
+      });
+      it('sets a value and returns the initial value of no changes', function () {
+        var obj = (0, _deepFreeze.default)({
+          name: 'Tommi',
+          age: 25
+        });
 
-            it('deepMerges and returns initial object when no values changed', function () {
-                var baseObj = (0, _deepFreeze2.default)({
-                    deep: {
-                        dontChange: 'John'
-                    }
-                });
-                var mergeObj = (0, _deepFreeze2.default)({
-                    deep: {
-                        dontChange: 'John'
-                    }
-                });
+        var result = _index.ops.set('age', 25, obj);
 
-                var result = _index.ops.deepMerge(mergeObj, baseObj);
-                expect(result).to.equal(baseObj);
-            });
-
-            it('omits a single key', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
-
-                var omitter = _index.ops.omit('age');
-                var result = omitter(obj);
-
-                expect((0, _index.canMutate)(result)).to.be.false;
-                expect(result).to.not.contain.keys(['age']);
-            });
-
-            it('omits a single key, returns same object if no value changes', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
-
-                var result = _index.ops.omit('location', obj);
-                expect(result).to.equal(obj);
-            });
-
-            it('omits an array of keys', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
-
-                var omitter = _index.ops.omit(['age']);
-                var result = omitter(obj);
-
-                expect((0, _index.canMutate)(result)).to.be.false;
-                expect(result).to.not.contain.keys(['age']);
-            });
-
-            it('sets a value', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
-
-                var result = _index.ops.set('age', 26, obj);
-                expect(result).to.deep.equal({
-                    name: 'Tommi',
-                    age: 26
-                });
-            });
-
-            it('sets a value and returns the initial value of no changes', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    name: 'Tommi',
-                    age: 25
-                });
-
-                var result = _index.ops.set('age', 25, obj);
-                expect(result).to.equal(obj);
-            });
-
-            it('sets a value in path', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    first: {
-                        second: {
-                            value: 'value',
-                            maintain: true
-                        },
-                        maintain: true
-                    },
-                    maintain: true
-                });
-
-                var setter = _index.ops.setIn('first.second.value', 'anotherValue');
-
-                var result = setter(obj);
-
-                expect((0, _index.canMutate)(result)).to.be.false;
-                expect(result).not.to.equal(obj);
-                expect(result.first.second.value).to.equal('anotherValue');
-                expect(result.maintain).to.be.true;
-                expect(result.first.maintain).to.be.true;
-                expect(result.first.second.maintain).to.be.true;
-            });
-
-            it('sets a value in path but returns same object if no value changes', function () {
-                var obj = (0, _deepFreeze2.default)({
-                    first: {
-                        second: {
-                            value: 'value',
-                            maintain: true
-                        },
-                        maintain: true
-                    },
-                    maintain: true
-                });
-
-                var result = _index.ops.setIn('first.second.value', 'value', obj);
-                expect(result).to.equal(obj);
-            });
+        expect(result).to.equal(obj);
+      });
+      it('sets a value in path', function () {
+        var obj = (0, _deepFreeze.default)({
+          first: {
+            second: {
+              value: 'value',
+              maintain: true
+            },
+            maintain: true
+          },
+          maintain: true
         });
-    });
 
-    describe('array', function () {
-        describe('batched mutations', function () {
-            var token = (0, _index.getBatchToken)();
+        var setter = _index.ops.setIn('first.second.value', 'anotherValue');
 
-            it('push', function () {
-                var push = _index.ops.batch.push;
-                var arr = (0, _deepFreeze2.default)([5, 4]);
-                var pusher = push(token, (0, _deepFreeze2.default)([1, 2, 3]));
-                var result = pusher(arr);
-
-                expect(result).to.not.equal(arr);
-
-                expect(result).to.deep.equal([5, 4, 1, 2, 3]);
-
-                var result2 = push(token, [4, 5], result);
-                expect(result).to.equal(result2);
-                expect(result2).to.deep.equal([5, 4, 1, 2, 3, 4, 5]);
-            });
-
-            it('insert', function () {
-                var insert = _index.ops.batch.insert;
-                var arr = (0, _deepFreeze2.default)([1, 2, 5]);
-                var inserter = insert(token, 2, (0, _deepFreeze2.default)([3, 4]));
-                var result = inserter(arr);
-
-                expect(result).to.deep.equal([1, 2, 3, 4, 5]);
-
-                var result2 = _index.ops.batch.insert(token, 2, [1000], result);
-                expect(result).to.equal(result2);
-                expect(result2).to.deep.equal([1, 2, 1000, 3, 4, 5]);
-            });
-
-            it('filter', function () {
-                var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
-                var result = _index.ops.batch.filter(token, function (item) {
-                    return item % 2 === 0;
-                }, arr);
-                expect((0, _index.canMutate)(result, token)).to.be.true;
-
-                expect(result).to.deep.equal([0, 2]);
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-
-                var result2 = _index.ops.batch.filter(token, function (item) {
-                    return item === 2;
-                }, result);
-                expect(result2).to.equal(result);
-                expect(result2).to.deep.equal([2]);
-            });
-
-            it('set', function () {
-                var arr = (0, _deepFreeze2.default)([1, 2, 987, 4]);
-
-                var setter = _index.ops.batch.set(token, 2, 3);
-                var result = setter(arr);
-                expect((0, _index.canMutate)(result, token)).to.be.true;
-
-                expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
-                expect(result).to.deep.equal([1, 2, 3, 4]);
-
-                var result2 = _index.ops.batch.set(token, 2, 1000, result);
-                expect(result).to.equal(result2);
-                expect(result2).to.deep.equal([1, 2, 1000, 4]);
-            });
-
-            it('splice with deletions', function () {
-                var splice = _index.ops.batch.splice;
-                var arr = (0, _deepFreeze2.default)([1, 2, 3, 3, 3, 4]);
-                var splicer = splice(token, 2, 2, []);
-
-                var result = splicer(arr);
-
-                expect(result).to.deep.equal([1, 2, 3, 4]);
-
-                var result2 = _index.ops.batch.splice(token, 2, 1, [], result);
-                expect(result2).to.equal(result);
-                expect(result2).to.deep.equal([1, 2, 4]);
-            });
-
-            it('splice with additions', function () {
-                var splice = _index.ops.batch.splice;
-                var arr = (0, _deepFreeze2.default)([1, 5]);
-                var splicer = splice(token, 1, 0, [2, 3, 4]);
-
-                var result = splicer(arr);
-
-                expect(result).to.deep.equal([1, 2, 3, 4, 5]);
-
-                var result2 = _index.ops.batch.splice(token, 0, 1, [1000], result);
-                expect(result).to.equal(result2);
-                expect(result2).to.deep.equal([1000, 2, 3, 4, 5]);
-            });
+        var result = setter(obj);
+        expect((0, _index.canMutate)(result)).to.be.false;
+        expect(result).not.to.equal(obj);
+        expect(result.first.second.value).to.equal('anotherValue');
+        expect(result.maintain).to.be.true;
+        expect(result.first.maintain).to.be.true;
+        expect(result.first.second.maintain).to.be.true;
+      });
+      it('sets a value in path but returns same object if no value changes', function () {
+        var obj = (0, _deepFreeze.default)({
+          first: {
+            second: {
+              value: 'value',
+              maintain: true
+            },
+            maintain: true
+          },
+          maintain: true
         });
 
-        describe('immutable ops', function () {
-            it('push', function () {
-                var push = _index.ops.push;
-                var arr = (0, _deepFreeze2.default)([5, 4]);
-                var pusher = push((0, _deepFreeze2.default)([1, 2, 3]));
-                var result = pusher(arr);
+        var result = _index.ops.setIn('first.second.value', 'value', obj);
 
-                expect(result).to.not.equal(arr);
+        expect(result).to.equal(obj);
+      });
+    });
+  });
+  describe('array', function () {
+    describe('batched mutations', function () {
+      var token = (0, _index.getBatchToken)();
+      it('push', function () {
+        var push = _index.ops.batch.push;
+        var arr = (0, _deepFreeze.default)([5, 4]);
+        var pusher = push(token, (0, _deepFreeze.default)([1, 2, 3]));
+        var result = pusher(arr);
+        expect(result).to.not.equal(arr);
+        expect(result).to.deep.equal([5, 4, 1, 2, 3]);
+        var result2 = push(token, [4, 5], result);
+        expect(result).to.equal(result2);
+        expect(result2).to.deep.equal([5, 4, 1, 2, 3, 4, 5]);
+      });
+      it('insert', function () {
+        var insert = _index.ops.batch.insert;
+        var arr = (0, _deepFreeze.default)([1, 2, 5]);
+        var inserter = insert(token, 2, (0, _deepFreeze.default)([3, 4]));
+        var result = inserter(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4, 5]);
+        var result2 = insert(token, 2, [1000], result);
+        expect(result).to.equal(result2);
+        expect(result2).to.deep.equal([1, 2, 1000, 3, 4, 5]);
+      });
+      it('filter', function () {
+        var arr = (0, _deepFreeze.default)([0, 1, 2, 3]);
 
-                expect(result).to.deep.equal([5, 4, 1, 2, 3]);
-            });
+        var result = _index.ops.batch.filter(token, function (item) {
+          return item % 2 === 0;
+        }, arr);
 
-            it('insert', function () {
-                var insert = _index.ops.insert;
-                var arr = (0, _deepFreeze2.default)([1, 2, 5]);
-                var inserter = insert(2, (0, _deepFreeze2.default)([3, 4]));
-                var result = inserter(arr);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect(result).to.deep.equal([0, 2]);
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
 
-                expect(result).to.deep.equal([1, 2, 3, 4, 5]);
-            });
+        var result2 = _index.ops.batch.filter(token, function (item) {
+          return item === 2;
+        }, result);
 
-            it('filter', function () {
-                var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
+        expect(result2).to.equal(result);
+        expect(result2).to.deep.equal([2]);
+      });
+      it('set', function () {
+        var set = _index.ops.batch.set;
+        var arr = (0, _deepFreeze.default)([1, 2, 987, 4]);
+        var setter = set(token, 2, 3);
+        var result = setter(arr);
+        expect((0, _index.canMutate)(result, token)).to.be.true;
+        expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
+        expect(result).to.deep.equal([1, 2, 3, 4]);
+        var result2 = set(token, 2, 1000, result);
+        expect(result).to.equal(result2);
+        expect(result2).to.deep.equal([1, 2, 1000, 4]);
+      });
+      it('splice with deletions', function () {
+        var splice = _index.ops.batch.splice;
+        var arr = (0, _deepFreeze.default)([1, 2, 3, 3, 3, 4]);
+        var splicer = splice(token, 2, 2, []);
+        var result = splicer(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4]);
+        var result2 = splice(token, 2, 1, [], result);
+        expect(result2).to.equal(result);
+        expect(result2).to.deep.equal([1, 2, 4]);
+      });
+      it('splice with additions', function () {
+        var splice = _index.ops.batch.splice;
+        var arr = (0, _deepFreeze.default)([1, 5]);
+        var splicer = splice(token, 1, 0, [2, 3, 4]);
+        var result = splicer(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4, 5]);
+        var result2 = splice(token, 0, 1, [1000], result);
+        expect(result).to.equal(result2);
+        expect(result2).to.deep.equal([1000, 2, 3, 4, 5]);
+      });
+    });
+    describe('immutable ops', function () {
+      it('push', function () {
+        var push = _index.ops.push;
+        var arr = (0, _deepFreeze.default)([5, 4]);
+        var pusher = push((0, _deepFreeze.default)([1, 2, 3]));
+        var result = pusher(arr);
+        expect(result).to.not.equal(arr);
+        expect(result).to.deep.equal([5, 4, 1, 2, 3]);
+      });
+      it('insert', function () {
+        var insert = _index.ops.insert;
+        var arr = (0, _deepFreeze.default)([1, 2, 5]);
+        var inserter = insert(2, (0, _deepFreeze.default)([3, 4]));
+        var result = inserter(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4, 5]);
+      });
+      it('filter', function () {
+        var arr = (0, _deepFreeze.default)([0, 1, 2, 3]);
 
-                var result = _index.ops.filter(function (item) {
-                    return item % 2 === 0;
-                }, arr);
+        var result = _index.ops.filter(function (item) {
+          return item % 2 === 0;
+        }, arr);
 
-                expect(result).to.deep.equal([0, 2]);
-                expect((0, _index.canMutate)(result)).to.be.false;
-            });
+        expect(result).to.deep.equal([0, 2]);
+        expect((0, _index.canMutate)(result)).to.be.false;
+      });
+      it('filter with no effect should return initial array', function () {
+        var arr = (0, _deepFreeze.default)([0, 1, 2, 3]);
 
-            it('filter with no effect should return initial array', function () {
-                var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
-                var result = _index.ops.filter(function (item) {
-                    return item < 4;
-                }, arr);
-                expect(result).to.equal(arr);
-            });
+        var result = _index.ops.filter(function (item) {
+          return item < 4;
+        }, arr);
 
-            it('set', function () {
-                var arr = (0, _deepFreeze2.default)([1, 2, 987, 4]);
+        expect(result).to.equal(arr);
+      });
+      it('set', function () {
+        var arr = (0, _deepFreeze.default)([1, 2, 987, 4]);
 
-                var result = _index.ops.set(2, 3, arr);
+        var result = _index.ops.set(2, 3, arr);
 
-                expect((0, _index.canMutate)(result)).to.be.false;
-                expect(result).to.deep.equal([1, 2, 3, 4]);
-            });
+        expect((0, _index.canMutate)(result)).to.be.false;
+        expect(result).to.deep.equal([1, 2, 3, 4]);
+      });
+      it('set with no effect should return initial array', function () {
+        var arr = (0, _deepFreeze.default)([1, 2, 3, 4]);
 
-            it('set with no effect should return initial array', function () {
-                var arr = (0, _deepFreeze2.default)([1, 2, 3, 4]);
+        var result = _index.ops.set(2, 3, arr);
 
-                var result = _index.ops.set(2, 3, arr);
-                expect(result).to.equal(arr);
-            });
-
-            it('splice with deletions', function () {
-                var splice = _index.ops.splice;
-                var arr = (0, _deepFreeze2.default)([1, 2, 3, 3, 3, 4]);
-                var splicer = splice(2, 2, []);
-
-                var result = splicer(arr);
-                expect(result).to.deep.equal([1, 2, 3, 4]);
-            });
-
-            it('splice with additions', function () {
-                var splice = _index.ops.splice;
-                var arr = (0, _deepFreeze2.default)([1, 5]);
-                var splicer = splice(1, 0, [2, 3, 4]);
-
-                var result = splicer(arr);
-
-                expect(result).to.deep.equal([1, 2, 3, 4, 5]);
-            });
-        });
+        expect(result).to.equal(arr);
+      });
+      it('splice with deletions', function () {
+        var splice = _index.ops.splice;
+        var arr = (0, _deepFreeze.default)([1, 2, 3, 3, 3, 4]);
+        var splicer = splice(2, 2, []);
+        var result = splicer(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4]);
+      });
+      it('splice with additions', function () {
+        var splice = _index.ops.splice;
+        var arr = (0, _deepFreeze.default)([1, 5]);
+        var splicer = splice(1, 0, [2, 3, 4]);
+        var result = splicer(arr);
+        expect(result).to.deep.equal([1, 2, 3, 4, 5]);
+      });
     });
+  });
 });

package.json

 {
   "name": "immutable-ops",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "A collection of functions to perform immutable operations on plain JavaScript objects",
   "main": "lib/index.js",
+  "module": "es/index.js",
   "scripts": {
     "test": "make test",
-    "prepublish": "make build"
+    "prepare": "make build",
+    "build": "make build",
+    "lint": "make lint"
   },
@@ -18,20 +21,30 @@ "keywords": [],
   "devDependencies": {
-    "babel-cli": "^6.18.0",
-    "babel-core": "^6.18.2",
-    "babel-eslint": "^7.1.0",
-    "babel-plugin-transform-runtime": "^6.15.0",
-    "babel-preset-es2015": "^6.18.0",
-    "babel-preset-stage-2": "^6.18.0",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-class-properties": "^7.0.0",
+    "@babel/plugin-proposal-decorators": "^7.0.0",
+    "@babel/plugin-proposal-export-namespace-from": "^7.0.0",
+    "@babel/plugin-proposal-function-sent": "^7.0.0",
+    "@babel/plugin-proposal-json-strings": "^7.0.0",
+    "@babel/plugin-proposal-numeric-separator": "^7.0.0",
+    "@babel/plugin-proposal-throw-expressions": "^7.0.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.0.0",
+    "@babel/plugin-syntax-import-meta": "^7.0.0",
+    "@babel/plugin-transform-runtime": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/register": "^7.0.0",
+    "@babel/runtime": "^7.3.4",
+    "babel-eslint": "^9.0.0",
     "chai": "^3.5.0",
     "deep-freeze": "0.0.1",
-    "eslint": "^3.10.0",
-    "eslint-config-airbnb-base": "10.0.1",
-    "eslint-plugin-import": "^2.2.0",
-    "mocha": "^3.1.2",
-    "sinon": "^1.17.6",
-    "sinon-chai": "^2.8.0"
+    "eslint": "^5.15.1",
+    "eslint-config-airbnb-base": "^13.1.0",
+    "eslint-plugin-import": "^2.16.0",
+    "mocha": "^6.0.2",
+    "sinon": "^7.2.7",
+    "sinon-chai": "^3.3.0"
   },
   "dependencies": {
-    "ramda": "^0.22.1"
+    "ramda": "^0.26.1"
   }
 }

src/index.js

@@ -1,3 +0,2 @@
-import curry from 'ramda/src/curry';
-import placeholder from 'ramda/src/__';
+import { curry, __ as placeholder } from 'ramda';
 
@@ -107,3 +106,3 @@ function forOwn(obj, fn) {
                 throw new Error(
-                    `A non-object value was encountered when traversing setIn path at ${pathRepr}.`,
+                    `A non-object value was encountered when traversing setIn path at ${pathRepr}.`
                 );
@@ -137,2 +136,3 @@ }
     }
+    return undefined;
 }
@@ -229,3 +229,3 @@
 
-function _shouldMergeKey(obj, other, key) {
+function shouldMergeKey(obj, other, key) {
     return obj[key] !== other[key];
@@ -254,4 +254,6 @@ }
                 if (typeof mergeValue === 'object' && !(mergeValue instanceof Array)) {
-                    if (_shouldMergeKey(nextObject, mergeObj, key)) {
-                        const recursiveMergeResult = immutableMerge(isDeep, ownerID, mergeValue, currentValue);
+                    if (shouldMergeKey(nextObject, mergeObj, key)) {
+                        const recursiveMergeResult = immutableMerge(
+                            isDeep, ownerID, mergeValue, currentValue
+                        );
 
@@ -266,6 +268,7 @@ if (recursiveMergeResult !== currentValue) {
             }
-            if (_shouldMergeKey(nextObject, mergeObj, key)) {
+            if (shouldMergeKey(nextObject, mergeObj, key)) {
                 willChange();
                 nextObject[key] = mergeValue;
             }
+            return undefined;
         });
@@ -272,0 +275,0 @@ });

src/test/testOperations.js

@@ -314,3 +314,3 @@ import chai from 'chai';
             it('push', () => {
-                const push = ops.batch.push;
+                const { push } = ops.batch;
                 const arr = freeze([5, 4]);
@@ -330,3 +330,3 @@ const pusher = push(token, freeze([1, 2, 3]));
             it('insert', () => {
-                const insert = ops.batch.insert;
+                const { insert } = ops.batch;
                 const arr = freeze([1, 2, 5]);
@@ -338,3 +338,3 @@ const inserter = insert(token, 2, freeze([3, 4]));
 
-                const result2 = ops.batch.insert(token, 2, [1000], result);
+                const result2 = insert(token, 2, [1000], result);
                 expect(result).to.equal(result2);
@@ -358,5 +358,6 @@ expect(result2).to.deep.equal([1, 2, 1000, 3, 4, 5]);
             it('set', () => {
+                const { set } = ops.batch;
                 const arr = freeze([1, 2, 987, 4]);
 
-                const setter = ops.batch.set(token, 2, 3);
+                const setter = set(token, 2, 3);
                 const result = setter(arr);
@@ -368,3 +369,3 @@ expect(canMutate(result, token)).to.be.true;
 
-                const result2 = ops.batch.set(token, 2, 1000, result);
+                const result2 = set(token, 2, 1000, result);
                 expect(result).to.equal(result2);
@@ -375,3 +376,3 @@ expect(result2).to.deep.equal([1, 2, 1000, 4]);
             it('splice with deletions', () => {
-                const splice = ops.batch.splice;
+                const { splice } = ops.batch;
                 const arr = freeze([1, 2, 3, 3, 3, 4]);
@@ -384,3 +385,3 @@ const splicer = splice(token, 2, 2, []);
 
-                const result2 = ops.batch.splice(token, 2, 1, [], result);
+                const result2 = splice(token, 2, 1, [], result);
                 expect(result2).to.equal(result);
@@ -391,3 +392,3 @@ expect(result2).to.deep.equal([1, 2, 4]);
             it('splice with additions', () => {
-                const splice = ops.batch.splice;
+                const { splice } = ops.batch;
                 const arr = freeze([1, 5]);
@@ -400,3 +401,3 @@ const splicer = splice(token, 1, 0, [2, 3, 4]);
 
-                const result2 = ops.batch.splice(token, 0, 1, [1000], result);
+                const result2 = splice(token, 0, 1, [1000], result);
                 expect(result).to.equal(result2);
@@ -409,3 +410,3 @@ expect(result2).to.deep.equal([1000, 2, 3, 4, 5]);
             it('push', () => {
-                const push = ops.push;
+                const { push } = ops;
                 const arr = freeze([5, 4]);
@@ -421,3 +422,3 @@ const pusher = push(freeze([1, 2, 3]));
             it('insert', () => {
-                const insert = ops.insert;
+                const { insert } = ops;
                 const arr = freeze([1, 2, 5]);
@@ -462,3 +463,3 @@ const inserter = insert(2, freeze([3, 4]));
             it('splice with deletions', () => {
-                const splice = ops.splice;
+                const { splice } = ops;
                 const arr = freeze([1, 2, 3, 3, 3, 4]);
@@ -472,3 +473,3 @@ const splicer = splice(2, 2, []);
             it('splice with additions', () => {
-                const splice = ops.splice;
+                const { splice } = ops;
                 const arr = freeze([1, 5]);
@@ -475,0 +476,0 @@ const splicer = splice(1, 0, [2, 3, 4]);

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

94781

increased by1.14%

Lines of code

2260

increased by49.17%

Worsened metrics

Dev dependency count

24

increased by71.43%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedramda@0.26.1(transitive)

• - Removedramda@0.22.1(transitive)

• Updatedramda@^0.26.1