@commercetools/sync-actions 4.11.0 → 5.0.0

package/dist/sync-actions.umd.js

@@ -18,14 +18,9 @@
 
     if (Object.getOwnPropertySymbols) {
       var symbols = Object.getOwnPropertySymbols(object);
-
-      if (enumerableOnly) {
-        symbols = symbols.filter(function (sym) {
-          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-        });
-      }
-
-      keys.push.apply(keys, symbols);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
     }
 
     return keys;
@@ -33,19 +28,12 @@
 
   function _objectSpread2(target) {
     for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i] != null ? arguments[i] : {};
-
-      if (i % 2) {
-        ownKeys(Object(source), true).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        });
-      } else if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-      } else {
-        ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-      }
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
     }
 
     return target;
@@ -54,17 +42,11 @@
   function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function (obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function (obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
 
   function _defineProperty(obj, key, value) {
@@ -2690,78 +2672,6 @@
   var HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';
   var keys = Object.keys;
   /**
-   * @function addToCache
-   *
-   * add object to cache if an object
-   *
-   * @param value the value to potentially add to cache
-   * @param cache the cache to add to
-   */
-
-  function addToCache(value, cache) {
-    if (value && _typeof(value) === 'object') {
-      cache.add(value);
-    }
-  }
-  /**
-   * @function hasPair
-   *
-   * @description
-   * does the `pairToMatch` exist in the list of `pairs` provided based on the
-   * `isEqual` check
-   *
-   * @param pairs the pairs to compare against
-   * @param pairToMatch the pair to match
-   * @param isEqual the equality comparator used
-   * @param meta the meta provided
-   * @returns does the pair exist in the pairs provided
-   */
-
-
-  function hasPair(pairs, pairToMatch, isEqual, meta) {
-    var length = pairs.length;
-    var pair;
-
-    for (var index = 0; index < length; index++) {
-      pair = pairs[index];
-
-      if (isEqual(pair[0], pairToMatch[0], meta) && isEqual(pair[1], pairToMatch[1], meta)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-  /**
-   * @function hasValue
-   *
-   * @description
-   * does the `valueToMatch` exist in the list of `values` provided based on the
-   * `isEqual` check
-   *
-   * @param values the values to compare against
-   * @param valueToMatch the value to match
-   * @param isEqual the equality comparator used
-   * @param meta the meta provided
-   * @returns does the value exist in the values provided
-   */
-
-
-  function hasValue(values, valueToMatch, isEqual, meta) {
-    var length = values.length;
-
-    for (var index = 0; index < length; index++) {
-      if (isEqual(values[index], valueToMatch, meta)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-  /**
-   * @function sameValueZeroEqual
-   *
-   * @description
    * are the values passed strictly equal or both NaN
    *
    * @param a the value to compare against
@@ -2769,14 +2679,10 @@
    * @returns are the values equal by the SameValueZero principle
    */
 
-
   function sameValueZeroEqual(a, b) {
     return a === b || a !== a && b !== b;
   }
   /**
-   * @function isPlainObject
-   *
-   * @description
    * is the value a plain object
    *
    * @param value the value to test
@@ -2788,9 +2694,6 @@
     return value.constructor === Object || value.constructor == null;
   }
   /**
-   * @function isPromiseLike
-   *
-   * @description
    * is the value promise-like (meaning it is thenable)
    *
    * @param value the value to test
@@ -2802,9 +2705,6 @@
     return !!value && typeof value.then === 'function';
   }
   /**
-   * @function isReactElement
-   *
-   * @description
    * is the value passed a react element
    *
    * @param value the value to test
@@ -2816,9 +2716,6 @@
     return !!(value && value.$$typeof);
   }
   /**
-   * @function getNewCacheFallback
-   *
-   * @description
    * in cases where WeakSet is not supported, creates a new custom
    * object that mimics the necessary API aspects for cache purposes
    *
@@ -2827,20 +2724,17 @@
 
 
   function getNewCacheFallback() {
-    return Object.create({
-      _values: [],
+    var values = [];
+    return {
       add: function add(value) {
-        this._values.push(value);
+        values.push(value);
       },
       has: function has(value) {
-        return this._values.indexOf(value) !== -1;
+        return values.indexOf(value) !== -1;
       }
-    });
+    };
   }
   /**
-   * @function getNewCache
-   *
-   * @description
    * get a new cache object to prevent circular references
    *
    * @returns the new cache object
@@ -2857,9 +2751,6 @@
     return getNewCacheFallback;
   }(HAS_WEAKSET_SUPPORT);
   /**
-   * @function createCircularEqualCreator
-   *
-   * @description
    * create a custom isEqual handler specific to circular objects
    *
    * @param [isEqual] the isEqual comparator to use instead of isDeepEqual
@@ -2876,61 +2767,31 @@
           cache = getNewCache();
         }
 
-        var hasA = cache.has(a);
-        var hasB = cache.has(b);
+        var isCacheableA = !!a && _typeof(a) === 'object';
+        var isCacheableB = !!b && _typeof(b) === 'object';
+
+        if (isCacheableA || isCacheableB) {
+          var hasA = isCacheableA && cache.has(a);
+          var hasB = isCacheableB && cache.has(b);
 
-        if (hasA || hasB) {
-          return hasA && hasB;
+          if (hasA || hasB) {
+            return hasA && hasB;
+          }
+
+          if (isCacheableA) {
+            cache.add(a);
+          }
+
+          if (isCacheableB) {
+            cache.add(b);
+          }
         }
 
-        addToCache(a, cache);
-        addToCache(b, cache);
         return _comparator(a, b, cache);
       };
     };
   }
   /**
-   * @function toPairs
-   *
-   * @description
-   * convert the map passed into pairs (meaning an array of [key, value] tuples)
-   *
-   * @param map the map to convert to [key, value] pairs (entries)
-   * @returns the [key, value] pairs
-   */
-
-
-  function toPairs(map) {
-    var pairs = new Array(map.size);
-    var index = 0;
-    map.forEach(function (value, key) {
-      pairs[index++] = [key, value];
-    });
-    return pairs;
-  }
-  /**
-   * @function toValues
-   *
-   * @description
-   * convert the set passed into values
-   *
-   * @param set the set to convert to values
-   * @returns the values
-   */
-
-
-  function toValues(set) {
-    var values = new Array(set.size);
-    var index = 0;
-    set.forEach(function (value) {
-      values[index++] = value;
-    });
-    return values;
-  }
-  /**
-   * @function areArraysEqual
-   *
-   * @description
    * are the arrays equal in value
    *
    * @param a the array to test
@@ -2942,13 +2803,13 @@
 
 
   function areArraysEqual(a, b, isEqual, meta) {
-    var length = a.length;
+    var index = a.length;
 
-    if (b.length !== length) {
+    if (b.length !== index) {
       return false;
     }
 
-    for (var index = 0; index < length; index++) {
+    while (index-- > 0) {
       if (!isEqual(a[index], b[index], meta)) {
         return false;
       }
@@ -2957,9 +2818,6 @@
     return true;
   }
   /**
-   * @function areMapsEqual
-   *
-   * @description
    * are the maps equal in value
    *
    * @param a the map to test
@@ -2971,29 +2829,36 @@
 
 
   function areMapsEqual(a, b, isEqual, meta) {
-    if (a.size !== b.size) {
-      return false;
-    }
-
-    var pairsA = toPairs(a);
-    var pairsB = toPairs(b);
-    var length = pairsA.length;
+    var isValueEqual = a.size === b.size;
+
+    if (isValueEqual && a.size) {
+      var matchedIndices_1 = {};
+      a.forEach(function (aValue, aKey) {
+        if (isValueEqual) {
+          var hasMatch_1 = false;
+          var matchIndex_1 = 0;
+          b.forEach(function (bValue, bKey) {
+            if (!hasMatch_1 && !matchedIndices_1[matchIndex_1]) {
+              hasMatch_1 = isEqual(aKey, bKey, meta) && isEqual(aValue, bValue, meta);
+
+              if (hasMatch_1) {
+                matchedIndices_1[matchIndex_1] = true;
+              }
+            }
 
-    for (var index = 0; index < length; index++) {
-      if (!hasPair(pairsB, pairsA[index], isEqual, meta) || !hasPair(pairsA, pairsB[index], isEqual, meta)) {
-        return false;
-      }
+            matchIndex_1++;
+          });
+          isValueEqual = hasMatch_1;
+        }
+      });
     }
 
-    return true;
+    return isValueEqual;
   }
 
   var OWNER = '_owner';
   var hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
   /**
-   * @function areObjectsEqual
-   *
-   * @description
    * are the objects equal in value
    *
    * @param a the object to test
@@ -3005,36 +2870,36 @@
 
   function areObjectsEqual(a, b, isEqual, meta) {
     var keysA = keys(a);
-    var length = keysA.length;
+    var index = keysA.length;
 
-    if (keys(b).length !== length) {
+    if (keys(b).length !== index) {
       return false;
     }
 
-    var key;
+    if (index) {
+      var key = void 0;
 
-    for (var index = 0; index < length; index++) {
-      key = keysA[index];
+      while (index-- > 0) {
+        key = keysA[index];
 
-      if (!hasOwnProperty(b, key)) {
-        return false;
-      }
+        if (key === OWNER) {
+          var reactElementA = isReactElement(a);
+          var reactElementB = isReactElement(b);
 
-      if (key === OWNER && isReactElement(a)) {
-        if (!isReactElement(b)) {
+          if ((reactElementA || reactElementB) && reactElementA !== reactElementB) {
+            return false;
+          }
+        }
+
+        if (!hasOwnProperty(b, key) || !isEqual(a[key], b[key], meta)) {
           return false;
         }
-      } else if (!isEqual(a[key], b[key], meta)) {
-        return false;
       }
     }
 
     return true;
   }
   /**
-   * @function areRegExpsEqual
-   *
-   * @description
    * are the regExps equal in value
    *
    * @param a the regExp to test
@@ -3047,9 +2912,6 @@
     return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.unicode === b.unicode && a.sticky === b.sticky && a.lastIndex === b.lastIndex;
   }
   /**
-   * @function areSetsEqual
-   *
-   * @description
    * are the sets equal in value
    *
    * @param a the set to test
@@ -3061,27 +2923,35 @@
 
 
   function areSetsEqual(a, b, isEqual, meta) {
-    if (a.size !== b.size) {
-      return false;
-    }
-
-    var valuesA = toValues(a);
-    var valuesB = toValues(b);
-    var length = valuesA.length;
+    var isValueEqual = a.size === b.size;
+
+    if (isValueEqual && a.size) {
+      var matchedIndices_2 = {};
+      a.forEach(function (aValue) {
+        if (isValueEqual) {
+          var hasMatch_2 = false;
+          var matchIndex_2 = 0;
+          b.forEach(function (bValue) {
+            if (!hasMatch_2 && !matchedIndices_2[matchIndex_2]) {
+              hasMatch_2 = isEqual(aValue, bValue, meta);
+
+              if (hasMatch_2) {
+                matchedIndices_2[matchIndex_2] = true;
+              }
+            }
 
-    for (var index = 0; index < length; index++) {
-      if (!hasValue(valuesB, valuesA[index], isEqual, meta) || !hasValue(valuesA, valuesB[index], isEqual, meta)) {
-        return false;
-      }
+            matchIndex_2++;
+          });
+          isValueEqual = hasMatch_2;
+        }
+      });
     }
 
-    return true;
+    return isValueEqual;
   }
 
-  var isArray = Array.isArray;
   var HAS_MAP_SUPPORT = typeof Map === 'function';
   var HAS_SET_SUPPORT = typeof Set === 'function';
-  var OBJECT_TYPEOF = 'object';
 
   function createComparator(createIsEqual) {
     var isEqual =
@@ -3090,9 +2960,6 @@
     /* eslint-enable */
 
     /**
-     * @function comparator
-     *
-     * @description
      * compare the value of the two objects and return true if they are equivalent in values
      *
      * @param a the value to test against
@@ -3102,34 +2969,34 @@
      */
 
     function comparator(a, b, meta) {
-      if (sameValueZeroEqual(a, b)) {
+      if (a === b) {
         return true;
       }
 
-      if (a && b && _typeof(a) === OBJECT_TYPEOF && _typeof(b) === OBJECT_TYPEOF) {
+      if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {
         if (isPlainObject(a) && isPlainObject(b)) {
           return areObjectsEqual(a, b, isEqual, meta);
         }
 
-        var arrayA = isArray(a);
-        var arrayB = isArray(b);
+        var aShape = Array.isArray(a);
+        var bShape = Array.isArray(b);
 
-        if (arrayA || arrayB) {
-          return arrayA === arrayB && areArraysEqual(a, b, isEqual, meta);
+        if (aShape || bShape) {
+          return aShape === bShape && areArraysEqual(a, b, isEqual, meta);
         }
 
-        var aDate = a instanceof Date;
-        var bDate = b instanceof Date;
+        aShape = a instanceof Date;
+        bShape = b instanceof Date;
 
-        if (aDate || bDate) {
-          return aDate === bDate && sameValueZeroEqual(a.getTime(), b.getTime());
+        if (aShape || bShape) {
+          return aShape === bShape && sameValueZeroEqual(a.getTime(), b.getTime());
         }
 
-        var aRegExp = a instanceof RegExp;
-        var bRegExp = b instanceof RegExp;
+        aShape = a instanceof RegExp;
+        bShape = b instanceof RegExp;
 
-        if (aRegExp || bRegExp) {
-          return aRegExp === bRegExp && areRegExpsEqual(a, b);
+        if (aShape || bShape) {
+          return aShape === bShape && areRegExpsEqual(a, b);
         }
 
         if (isPromiseLike(a) || isPromiseLike(b)) {
@@ -3137,32 +3004,31 @@
         }
 
         if (HAS_MAP_SUPPORT) {
-          var aMap = a instanceof Map;
-          var bMap = b instanceof Map;
+          aShape = a instanceof Map;
+          bShape = b instanceof Map;
 
-          if (aMap || bMap) {
-            return aMap === bMap && areMapsEqual(a, b, isEqual, meta);
+          if (aShape || bShape) {
+            return aShape === bShape && areMapsEqual(a, b, isEqual, meta);
           }
         }
 
         if (HAS_SET_SUPPORT) {
-          var aSet = a instanceof Set;
-          var bSet = b instanceof Set;
+          aShape = a instanceof Set;
+          bShape = b instanceof Set;
 
-          if (aSet || bSet) {
-            return aSet === bSet && areSetsEqual(a, b, isEqual, meta);
+          if (aShape || bShape) {
+            return aShape === bShape && areSetsEqual(a, b, isEqual, meta);
           }
         }
 
         return areObjectsEqual(a, b, isEqual, meta);
       }
 
-      return false;
+      return a !== a && b !== b;
     }
 
     return comparator;
-  } // comparator
-
+  }
 
   var deepEqual = createComparator();
   createComparator(function () {
@@ -3607,14 +3473,14 @@
     });
   }
 
-  function actionsMapEnums(attributeType, attributeDiff, previous, next) {
+  function actionsMapEnums(fieldName, attributeType, attributeDiff, previous, next) {
     var _createBuildArrayActi;
 
-    var addEnumActionName = attributeType === 'enum' ? 'addEnumValue' : 'addLocalizedEnumValue';
-    var changeEnumOrderActionName = attributeType === 'enum' ? 'changeEnumValueOrder' : 'changeLocalizedEnumValueOrder';
+    var addEnumActionName = attributeType === 'Enum' ? 'addEnumValue' : 'addLocalizedEnumValue';
+    var changeEnumOrderActionName = attributeType === 'Enum' ? 'changeEnumValueOrder' : 'changeLocalizedEnumValueOrder';
     var buildArrayActions = createBuildArrayActions('values', (_createBuildArrayActi = {}, _defineProperty(_createBuildArrayActi, ADD_ACTIONS, function (newEnum) {
       return {
-        fieldName: next.name,
+        fieldName: fieldName,
         action: addEnumActionName,
         value: newEnum
       };
@@ -3630,13 +3496,13 @@
 
       if (oldEnumInNext) {
         changeActions.push({
-          fieldName: next.name,
+          fieldName: fieldName,
           action: changeEnumOrderActionName,
           value: newEnum
         });
       } else {
         changeActions.push({
-          fieldName: next.name,
+          fieldName: fieldName,
           action: addEnumActionName,
           value: newEnum
         });
@@ -3654,7 +3520,7 @@
       } else actions.push(updateAction);
     });
     return [].concat(actions, _toConsumableArray(newEnumValuesOrder.length > 0 ? [{
-      fieldName: next.name,
+      fieldName: fieldName,
       action: changeEnumOrderActionName,
       keys: newEnumValuesOrder
     }] : []));
@@ -3682,7 +3548,7 @@
             fieldName: extractedPairs.oldObj.name
           });
         } else if (diffValue.type.values) {
-          actions.push.apply(actions, _toConsumableArray(actionsMapEnums(extractedPairs.oldObj.type.name, diffValue.type, extractedPairs.oldObj.type, extractedPairs.newObj.type)));
+          actions.push.apply(actions, _toConsumableArray(actionsMapEnums(extractedPairs.oldObj.name, extractedPairs.oldObj.type.name, diffValue.type, extractedPairs.oldObj.type, extractedPairs.newObj.type)));
         }
       } else if (getIsRemovedOperation(diffKey)) {
         if (Array.isArray(diffValue)) {