@bonlineza/luxity-lib 2.34.2 → 2.34.4

package/ShoeSizeRangeSelector.js

@@ -7,89 +7,128 @@
   var React__default = 'default' in React ? React['default'] : React;
   var styled__default = 'default' in styled ? styled['default'] : styled;
 
-  function _arrayLikeToArray(r, a) {
-    (null == a || a > r.length) && (a = r.length);
-    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-    return n;
-  }
-  function _arrayWithHoles(r) {
-    if (Array.isArray(r)) return r;
-  }
   function _extends() {
-    return _extends = Object.assign ? Object.assign.bind() : function (n) {
-      for (var e = 1; e < arguments.length; e++) {
-        var t = arguments[e];
-        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-      }
-      return n;
-    }, _extends.apply(null, arguments);
-  }
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = !0,
-        o = !1;
-      try {
-        if (i = (t = t.call(r)).next, 0 === l) {
-          if (Object(t) !== t) return;
-          f = !1;
-        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = !0, n = r;
-      } finally {
-        try {
-          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
         }
       }
-      return a;
-    }
+
+      return target;
+    };
+    return _extends.apply(this, arguments);
   }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+
+    return target;
   }
-  function _objectWithoutProperties(e, t) {
-    if (null == e) return {};
-    var o,
-      r,
-      i = _objectWithoutPropertiesLoose(e, t);
+
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+
+    var key, i;
+
     if (Object.getOwnPropertySymbols) {
-      var s = Object.getOwnPropertySymbols(e);
-      for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
     }
-    return i;
+
+    return target;
   }
-  function _objectWithoutPropertiesLoose(r, e) {
-    if (null == r) return {};
-    var t = {};
-    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-      if (e.includes(n)) continue;
-      t[n] = r[n];
+
+  function _taggedTemplateLiteral(strings, raw) {
+    if (!raw) {
+      raw = strings.slice(0);
     }
-    return t;
-  }
-  function _slicedToArray(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-  }
-  function _taggedTemplateLiteral(e, t) {
-    return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, {
+
+    return Object.freeze(Object.defineProperties(strings, {
       raw: {
-        value: Object.freeze(t)
+        value: Object.freeze(raw)
       }
     }));
   }
-  function _unsupportedIterableToArray(r, a) {
-    if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray(r, a);
-      var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+
+    var _s, _e;
+
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
     }
+
+    return _arr;
+  }
+
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
   var theme = {
@@ -157,82 +196,117 @@
   });
 
   function _extends$1() {
-    return _extends$1 = Object.assign ? Object.assign.bind() : function (n) {
-      for (var e = 1; e < arguments.length; e++) {
-        var t = arguments[e];
-        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
       }
-      return n;
-    }, _extends$1.apply(null, arguments);
+
+      return target;
+    };
+    return _extends$1.apply(this, arguments);
   }
 
-  function _assertThisInitialized(e) {
-    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    return e;
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return self;
   }
 
-  function _setPrototypeOf(t, e) {
-    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
-      return t.__proto__ = e, t;
-    }, _setPrototypeOf(t, e);
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
   }
 
-  function _inheritsLoose(t, o) {
-    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    _setPrototypeOf(subClass, superClass);
   }
 
-  function _getPrototypeOf(t) {
-    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
-      return t.__proto__ || Object.getPrototypeOf(t);
-    }, _getPrototypeOf(t);
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
   }
 
-  function _isNativeFunction(t) {
-    try {
-      return -1 !== Function.toString.call(t).indexOf("[native code]");
-    } catch (n) {
-      return "function" == typeof t;
-    }
+  function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
   }
 
   function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+
     try {
-      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    } catch (t) {}
-    return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
-      return !!t;
-    })();
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 
-  function _construct(t, e, r) {
-    if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
-    var o = [null];
-    o.push.apply(o, e);
-    var p = new (t.bind.apply(t, o))();
-    return r && _setPrototypeOf(p, r.prototype), p;
+  function _construct(Parent, args, Class) {
+    if (_isNativeReflectConstruct()) {
+      _construct = Reflect.construct.bind();
+    } else {
+      _construct = function _construct(Parent, args, Class) {
+        var a = [null];
+        a.push.apply(a, args);
+        var Constructor = Function.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) _setPrototypeOf(instance, Class.prototype);
+        return instance;
+      };
+    }
+
+    return _construct.apply(null, arguments);
   }
 
-  function _wrapNativeSuper(t) {
-    var r = "function" == typeof Map ? new Map() : void 0;
-    return _wrapNativeSuper = function _wrapNativeSuper(t) {
-      if (null === t || !_isNativeFunction(t)) return t;
-      if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
-      if (void 0 !== r) {
-        if (r.has(t)) return r.get(t);
-        r.set(t, Wrapper);
+  function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+      if (Class === null || !_isNativeFunction(Class)) return Class;
+
+      if (typeof Class !== "function") {
+        throw new TypeError("Super expression must either be null or a function");
       }
+
+      if (typeof _cache !== "undefined") {
+        if (_cache.has(Class)) return _cache.get(Class);
+
+        _cache.set(Class, Wrapper);
+      }
+
       function Wrapper() {
-        return _construct(t, arguments, _getPrototypeOf(this).constructor);
+        return _construct(Class, arguments, _getPrototypeOf(this).constructor);
       }
-      return Wrapper.prototype = Object.create(t.prototype, {
+
+      Wrapper.prototype = Object.create(Class.prototype, {
         constructor: {
           value: Wrapper,
-          enumerable: !1,
-          writable: !0,
-          configurable: !0
+          enumerable: false,
+          writable: true,
+          configurable: true
         }
-      }), _setPrototypeOf(Wrapper, t);
-    }, _wrapNativeSuper(t);
+      });
+      return _setPrototypeOf(Wrapper, Class);
+    };
+
+    return _wrapNativeSuper(Class);
   }
 
   // based on https://github.com/styled-components/styled-components/blob/fcf6f3804c57a14dd7984dfab7bc06ee2edca044/src/utils/error.js
@@ -901,9 +975,10 @@
   }, function (props) {
     return getSliderMarkStyle(props);
   });
+
   var getSliderMarkStyle = function getSliderMarkStyle(_ref) {
     var showMarks = _ref.showMarks,
-      primary = _ref.theme.colors.primary;
+        primary = _ref.theme.colors.primary;
     var visiblityStyle = showMarks ? styled.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral([""]))) : styled.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n        .rc-slider-mark-text,\n        .rc-slider-dot {\n          visibility: hidden;\n        }\n      "])));
     return styled.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n    .rc-slider-mark-text {\n      color: ", ";\n    }\n\n    .rc-slider-dot {\n      border-color: ", ";\n      background-color: white;\n    }\n    ", "\n  "])), primary, primary, visiblityStyle);
   };
@@ -915,24 +990,28 @@
   var Footer = styled__default.div(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-flow: row nowrap;\n  justify-content: flex-end;\n"])));
 
   var _excluded = ["dragging", "value", "offset", "index"],
-    _excluded2 = ["renderTitleSection", "marks", "defaultMinValue", "defaultMaxValue", "min", "max", "toolTipComponent", "renderFooterSection", "onChange", "children", "identifier", "showMarks"];
+      _excluded2 = ["renderTitleSection", "marks", "defaultMinValue", "defaultMaxValue", "min", "max", "toolTipComponent", "renderFooterSection", "onChange", "children", "identifier", "showMarks"];
+
   var _templateObject$4;
   var debounceBuilder = functions.debounced(100);
   var ChildrenWrapper = styled__default.div(_templateObject$4 || (_templateObject$4 = _taggedTemplateLiteral(["\n  margin-bottom: ", ";\n"])), function (props) {
     return props.theme.marginPaddings[3];
   });
+
   var renderCustomHandle = function renderCustomHandle() {
     var marks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var toolTipComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     var handleProps = arguments.length > 2 ? arguments[2] : undefined;
+
     var dragging = handleProps.dragging,
-      value = handleProps.value,
-      offset = handleProps.offset,
-      index = handleProps.index,
-      restHandleProps = _objectWithoutProperties(handleProps, _excluded);
+        value = handleProps.value,
+        offset = handleProps.offset,
+        index = handleProps.index,
+        restHandleProps = _objectWithoutProperties(handleProps, _excluded);
+
     var getToolTipProps = function getToolTipProps() {
-      var newProps = {};
-      // Ensures that Tooltip component does not get ref prop
+      var newProps = {}; // Ensures that Tooltip component does not get ref prop
+
       Object.keys(handleProps).forEach(function (propName) {
         if (propName !== 'ref') {
           newProps[propName] = handleProps[propName];
@@ -940,6 +1019,7 @@
       });
       return newProps;
     };
+
     var Tooltip = toolTipComponent;
     return /*#__PURE__*/React__default.createElement(React.Fragment, {
       key: index
@@ -956,47 +1036,55 @@
       marks: marks
     }, getToolTipProps()))));
   };
-
   /** slider ui component for react */
+
+
   var RangeSlider = function RangeSlider(_ref) {
     var renderTitleSection = _ref.renderTitleSection,
-      marks = _ref.marks,
-      defaultMinValue = _ref.defaultMinValue,
-      defaultMaxValue = _ref.defaultMaxValue,
-      min = _ref.min,
-      max = _ref.max,
-      toolTipComponent = _ref.toolTipComponent,
-      renderFooterSection = _ref.renderFooterSection,
-      onChange = _ref.onChange,
-      childRenderer = _ref.children,
-      identifier = _ref.identifier,
-      showMarks = _ref.showMarks,
-      restProps = _objectWithoutProperties(_ref, _excluded2);
+        marks = _ref.marks,
+        defaultMinValue = _ref.defaultMinValue,
+        defaultMaxValue = _ref.defaultMaxValue,
+        min = _ref.min,
+        max = _ref.max,
+        toolTipComponent = _ref.toolTipComponent,
+        renderFooterSection = _ref.renderFooterSection,
+        onChange = _ref.onChange,
+        childRenderer = _ref.children,
+        identifier = _ref.identifier,
+        showMarks = _ref.showMarks,
+        restProps = _objectWithoutProperties(_ref, _excluded2);
+
     var _useState = React.useState(defaultMinValue),
-      _useState2 = _slicedToArray(_useState, 2),
-      currMinVal = _useState2[0],
-      setMinVal = _useState2[1];
+        _useState2 = _slicedToArray(_useState, 2),
+        currMinVal = _useState2[0],
+        setMinVal = _useState2[1];
+
     var _useState3 = React.useState(defaultMaxValue),
-      _useState4 = _slicedToArray(_useState3, 2),
-      currMaxVal = _useState4[0],
-      setMaxVal = _useState4[1];
+        _useState4 = _slicedToArray(_useState3, 2),
+        currMaxVal = _useState4[0],
+        setMaxVal = _useState4[1];
     /*
      *Description variable stores the time that the component renders
      * the state is used to enforce reenders for the component since the date now
      * is always changing
      * */
+
+
     var _useState5 = React.useState(0),
-      _useState6 = _slicedToArray(_useState5, 2),
-      seed = _useState6[0],
-      setSeed = _useState6[1];
+        _useState6 = _slicedToArray(_useState5, 2),
+        seed = _useState6[0],
+        setSeed = _useState6[1];
+
     var manuallyChangeMinValue = function manuallyChangeMinValue(val) {
       setMinVal(val);
       setSeed(Date.now());
     };
+
     var manuallyChangeMaxValue = function manuallyChangeMaxValue(val) {
       setMaxVal(val);
       setSeed(Date.now());
     };
+
     var prevMinVal = functions.usePrevious(currMinVal);
     var prevMaxVal = functions.usePrevious(currMaxVal);
     React.useEffect(function () {
@@ -1032,8 +1120,9 @@
       defaultValue: [defaultMinValue, defaultMaxValue],
       onChange: function onChange(_ref2) {
         var _ref3 = _slicedToArray(_ref2, 2),
-          nextMin = _ref3[0],
-          nextMax = _ref3[1];
+            nextMin = _ref3[0],
+            nextMax = _ref3[1];
+
         setMinVal(nextMin);
         setMaxVal(nextMax);
       },
@@ -1046,6 +1135,7 @@
       allowCross: false
     }, restProps)), /*#__PURE__*/React__default.createElement(Footer, null, renderFooterSection(actionsObj)));
   };
+
   RangeSlider.defaultProps = {
     renderTitleSection: function renderTitleSection() {
       return false;
@@ -1083,38 +1173,43 @@
     Eu: 'Eu',
     Us: 'Us'
   };
+
   var getMaxShoeSize = function getMaxShoeSize(euShoeSizes, ukShoeSizes, type) {
     var shoeSizes = ukShoeSizes;
+
     if (type === (shoeSizeType === null || shoeSizeType === void 0 ? void 0 : shoeSizeType.Eu)) {
       shoeSizes = euShoeSizes;
     }
+
     var sizes = shoeSizes.map(function (item) {
       return parseFloat(item.size);
-    });
+    }); // Use the Math.max function to find the maximum size value
 
-    // Use the Math.max function to find the maximum size value
     var maxSize = sizes.reduce(function (max, current) {
       return Math.max(max, current);
     }, -50);
     return maxSize;
   };
-
   /** UI Slider with minimum and max input fields give the ability to
    * select a shoe size range */
+
+
   var ShoeSizeRangeSelector = function ShoeSizeRangeSelector(_ref) {
     var onChange = _ref.onChange,
-      euShoeSizes = _ref.euShoeSizes,
-      ukShoeSizes = _ref.ukShoeSizes,
-      sizeType = _ref.sizeType;
+        euShoeSizes = _ref.euShoeSizes,
+        ukShoeSizes = _ref.ukShoeSizes,
+        sizeType = _ref.sizeType;
     var maxShoeSize = getMaxShoeSize(euShoeSizes, ukShoeSizes, sizeType);
+
     var handleSlideChange = function handleSlideChange(value) {
       var min_shoe_size = value.min,
-        max_shoe_size = value.max;
+          max_shoe_size = value.max;
       onChange({
         min_shoe_size: min_shoe_size,
         max_shoe_size: max_shoe_size
       });
     };
+
     var handleMinShoeSizeChange = function handleMinShoeSizeChange(targetValue, currMaxVal, manuallyChangeMinValue) {
       var value = parseInt(targetValue, 10);
       value = Number.isNaN(value) ? 0 : value;
@@ -1127,6 +1222,7 @@
         });
       });
     };
+
     var handleMaxShoeSizeChange = function handleMaxShoeSizeChange(targetValue, currMinVal, manuallyChangeMaxValue) {
       var value = parseInt(targetValue, 10);
       value = Number.isNaN(value) ? 0 : value;
@@ -1139,6 +1235,7 @@
         });
       });
     };
+
     return /*#__PURE__*/React__default.createElement("div", {
       className: "shoe-size-ranges"
     }, /*#__PURE__*/React__default.createElement(RangeSlider$1, {
@@ -1151,9 +1248,9 @@
       title: "Shoe Size Ranges"
     }, function (_ref2) {
       var manuallyChangeMinValue = _ref2.manuallyChangeMinValue,
-        manuallyChangeMaxValue = _ref2.manuallyChangeMaxValue,
-        currMinVal = _ref2.currMinVal,
-        currMaxVal = _ref2.currMaxVal;
+          manuallyChangeMaxValue = _ref2.manuallyChangeMaxValue,
+          currMinVal = _ref2.currMinVal,
+          currMaxVal = _ref2.currMaxVal;
       return /*#__PURE__*/React__default.createElement(ShoeSizeInputWrapper, null, /*#__PURE__*/React__default.createElement("input", {
         "data-qe-id": "masked-input-min",
         value: currMinVal,
@@ -1169,6 +1266,7 @@
       }));
     }));
   };
+
   ShoeSizeRangeSelector.defaultProps = {
     onChange: function onChange() {
       return false;