@configuratorware/configurator-frontendgui 1.28.5 → 1.29.2

package/Shared/Components/MainButton.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.mainButtonStyle = void 0;
+
+var _core = require("@material-ui/core");
+
+var _Button = _interopRequireDefault(require("@material-ui/core/Button/Button"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _excluded = ["classes"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { 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 target; }
+
+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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }
+
+function _objectSpread(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)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var mainButtonStyle = function mainButtonStyle(theme) {
+  var buttons = _objectSpread({
+    mainBtn: {},
+    mainBtnHover: {}
+  }, theme.buttons);
+
+  return {
+    root: _objectSpread(_objectSpread({}, buttons.mainBtn), {}, {
+      '&:hover': _objectSpread(_objectSpread({}, buttons.mainBtnHover), {}, {
+        cursor: 'pointer'
+      }),
+      '@media (hover: none)': {
+        '&:hover': _objectSpread({}, buttons.mainBtn)
+      },
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center'
+    }),
+    label: {
+      color: 'white',
+      fontSize: 15,
+      textTransform: 'none',
+      whiteSpace: 'nowrap'
+    }
+  };
+};
+
+exports.mainButtonStyle = mainButtonStyle;
+
+var MainButton = /*#__PURE__*/_react["default"].forwardRef(function (_ref, ref) {
+  var classes = _ref.classes,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/_react["default"].createElement(_Button["default"], _extends({
+    classes: classes
+  }, props, {
+    ref: ref
+  }));
+});
+
+MainButton.propTypes = {
+  classes: _propTypes["default"].object
+};
+MainButton.displayName = 'MainButton';
+
+var _default = (0, _core.withStyles)(mainButtonStyle, {
+  name: 'MainButton'
+})(MainButton);
+
+exports["default"] = _default;

package/Shared/ErrorTypes/DeferredError.js

@@ -0,0 +1,51 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.DeferredError = void 0;
+
+var _CustomError2 = _interopRequireDefault(require("../../Framework/CustomError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var DeferredError = /*#__PURE__*/function (_CustomError) {
+  _inherits(DeferredError, _CustomError);
+
+  var _super = _createSuper(DeferredError);
+
+  function DeferredError(message) {
+    _classCallCheck(this, DeferredError);
+
+    return _super.call(this, DeferredError.type, message);
+  }
+
+  return DeferredError;
+}(_CustomError2["default"]);
+
+exports.DeferredError = DeferredError;
+
+_defineProperty(DeferredError, "type", 'DeferredError');
+
+var _default = DeferredError;
+exports["default"] = _default;

package/Shared/HOCs/ResizeDetect/ResizeDetect.dev.js

@@ -0,0 +1,60 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _ResizeDetect = require("./ResizeDetect");
+
+var _withStyles = _interopRequireDefault(require("@material-ui/core/styles/withStyles"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var styles = {
+  test: {
+    transition: 'all 0.3s',
+    width: '20%',
+    minWidth: 180,
+    background: 'green',
+    color: 'white',
+    padding: '5%',
+    height: 50,
+    '&:hover': {
+      width: '90%',
+      height: 500
+    }
+  }
+};
+var RenderPropVersion = (0, _ResizeDetect.withResizeDetect)((0, _withStyles["default"])(styles, {
+  name: 'ResizeDetect'
+})(function (_ref) {
+  var containerRef = _ref.containerRef,
+      size = _ref.size,
+      classes = _ref.classes;
+  return /*#__PURE__*/React.createElement("div", {
+    className: classes.test,
+    ref: containerRef
+  }, "Hover me to test! ", size.width, "x", size.height);
+}));
+var WrapperVersion = (0, _ResizeDetect.withResizeDetectWrapper)(function (_ref2) {
+  var size = _ref2.size;
+  return /*#__PURE__*/React.createElement("div", null, "Hover me to test! ", size.width, "x", size.height);
+}); // eslint-disable-next-line no-unused-vars
+
+var StyledWrapper = (0, _withStyles["default"])(styles)(function (_ref3) {
+  var classes = _ref3.classes;
+  return /*#__PURE__*/React.createElement(WrapperVersion, {
+    className: classes.test
+  });
+});
+var _default = RenderPropVersion;
+exports["default"] = _default;

package/Shared/HOCs/ResizeDetect/ResizeDetect.js

@@ -0,0 +1,217 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withResizeDetectWrapper = exports.withResizeDetect = exports.ResizeDetect = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _cssElementQueries = require("css-element-queries");
+
+var _ReactComponent = _interopRequireDefault(require("../../PropTypes/ReactComponent"));
+
+var _getDisplayName = _interopRequireDefault(require("../getDisplayName"));
+
+var _excluded = ["onSizeChange", "WrapperComponent"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { 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 target; }
+
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var initialState = {
+  size: {
+    width: 0,
+    height: 0
+  }
+};
+
+var ResizeDetectContext = /*#__PURE__*/_react["default"].createContext(initialState);
+/**
+ * Wrap a component with the ResizeSensor
+ * Usage modes:
+ *  1. children prop is the wrapped component
+ *      -> add a container around it and apply the ResizeSensor on the wrapper container
+ *  2. children prop is a render prop
+ *      -> define the dom element reference for the ResizeSensor container inside the render prop with containerRef
+ */
+
+
+var ResizeDetect = /*#__PURE__*/function (_React$Component) {
+  _inherits(ResizeDetect, _React$Component);
+
+  var _super = _createSuper(ResizeDetect);
+
+  function ResizeDetect() {
+    var _this;
+
+    _classCallCheck(this, ResizeDetect);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "state", initialState);
+
+    _defineProperty(_assertThisInitialized(_this), "updateState", function () {
+      var container = _this.getContainer();
+
+      var _container$getBoundin = container.getBoundingClientRect(),
+          width = _container$getBoundin.width,
+          height = _container$getBoundin.height;
+
+      var size = {
+        width: Math.floor(width),
+        height: Math.floor(height)
+      };
+
+      _this.setState({
+        size: size
+      });
+
+      var onSizeChange = _this.props.onSizeChange;
+      onSizeChange && onSizeChange(size);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "containerRef", /*#__PURE__*/_react["default"].createRef());
+
+    return _this;
+  }
+
+  _createClass(ResizeDetect, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var container = this.getContainer();
+      this.resizeSensor = new _cssElementQueries.ResizeSensor(container, this.updateState); // trigger change for the first time
+
+      this.updateState();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      // releasing resize sensor
+      this.resizeSensor.detach();
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      var container = this.containerRef.current;
+
+      if (!container) {
+        throw new TypeError('ResizeDetect can only work with children as a render prop or with the wrapper mode on.');
+      }
+
+      return container;
+    }
+  }, {
+    key: "getProps",
+    value: function getProps() {
+      // eslint-disable-next-line no-unused-vars
+      var _this$props = this.props,
+          onSizeChange = _this$props.onSizeChange,
+          WrapperComponent = _this$props.WrapperComponent,
+          otherProps = _objectWithoutProperties(_this$props, _excluded);
+
+      return otherProps;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+          children = _this$props2.children,
+          WrapperComponent = _this$props2.WrapperComponent,
+          wrapperClassName = _this$props2.wrapperClassName,
+          wrapperProps = _this$props2.wrapperProps;
+      var Container = WrapperComponent || 'div';
+      return typeof children !== 'function' ? /*#__PURE__*/_react["default"].createElement(ResizeDetectContext.Provider, {
+        value: this.state
+      }, /*#__PURE__*/_react["default"].createElement(Container, _extends({
+        className: wrapperClassName,
+        ref: this.containerRef
+      }, wrapperProps), children)) : children({
+        containerRef: this.containerRef,
+        size: this.state.size,
+        containerProps: this.getProps()
+      });
+    }
+  }]);
+
+  return ResizeDetect;
+}(_react["default"].Component);
+/**
+ * HOC for the 2. usage mode (provides the Component as a render function directly, so it can get the props)
+ * Hint: in this case don't forget to use the containerRef inside the component to define the container element
+ * for the ResizeSensor.
+ * @param Component
+ */
+
+
+exports.ResizeDetect = ResizeDetect;
+
+_defineProperty(ResizeDetect, "propTypes", {
+  onSizeChange: _propTypes["default"].func,
+  WrapperComponent: _propTypes["default"].oneOfType([_ReactComponent["default"], _propTypes["default"].string]),
+  wrapperClassName: _propTypes["default"].string,
+  wrapperProps: _propTypes["default"].object,
+  children: _propTypes["default"].any
+});
+
+var withResizeDetect = function withResizeDetect(Component) {
+  var WithResizeDetect = function WithResizeDetect() {
+    return /*#__PURE__*/_react["default"].createElement(ResizeDetect, null, function (props) {
+      return /*#__PURE__*/_react["default"].createElement(Component, props);
+    });
+  };
+
+  WithResizeDetect.displayName = "WithResizeDetect(".concat((0, _getDisplayName["default"])(Component), ")");
+  return WithResizeDetect;
+};
+/**
+ * HOC for the 1. usage mode (adds a wrapper div around the component)
+ * @param Component
+ */
+
+
+exports.withResizeDetect = withResizeDetect;
+
+var withResizeDetectWrapper = function withResizeDetectWrapper(Component) {
+  return function (props) {
+    return /*#__PURE__*/_react["default"].createElement(ResizeDetect, props, /*#__PURE__*/_react["default"].createElement(ResizeDetectContext.Consumer, null, function (state) {
+      return /*#__PURE__*/_react["default"].createElement(Component, _extends({}, state, props));
+    }));
+  };
+};
+
+exports.withResizeDetectWrapper = withResizeDetectWrapper;

package/Shared/HOCs/getDisplayName.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getDisplayName;
+
+function getDisplayName(WrappedComponent) {
+  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+}

package/Shared/HOCs/withFixedChangeHandler.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withFixedChangeHandler = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }
+
+function _objectSpread(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)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var withFixedChangeHandler = function withFixedChangeHandler(Component) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$getValueFrom = options.getValueFromArgs,
+      getValueFromArgs = _options$getValueFrom === void 0 ? function (evt) {
+    return evt.target.value;
+  } : _options$getValueFrom;
+
+  var FixChangeHandler = function FixChangeHandler(props) {
+    var fixedProps = _objectSpread({}, props);
+
+    if (fixedProps.onChange) {
+      fixedProps.onChange = function () {
+        return props.onChange && getValueFromArgs.apply(void 0, arguments) !== props.value && props.onChange.apply(props, arguments);
+      };
+    }
+
+    return /*#__PURE__*/_react["default"].createElement(Component, fixedProps);
+  };
+
+  FixChangeHandler.propTypes = {
+    onChange: _propTypes["default"].func,
+    value: _propTypes["default"].node
+  };
+  return FixChangeHandler;
+};
+
+exports.withFixedChangeHandler = withFixedChangeHandler;

package/Shared/PropTypes/ReactComponent.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _default = _propTypes["default"].elementType;
+exports["default"] = _default;

package/Shared/Styles/absoluteCenter.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.absoluteCenter = void 0;
+
+var absoluteCenter = function absoluteCenter() {
+  return {
+    position: 'absolute',
+    top: '50%',
+    left: '50%',
+    transform: 'translate(-50%,-50%)'
+  };
+};
+
+exports.absoluteCenter = absoluteCenter;

package/Utils/Array/isIdentical.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.isIdentical = void 0;
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Shallow-equal compare of two arrays
+ * @param {array} a0
+ * @param {array} a1
+ * @returns {boolean}
+ */
+var isIdentical = function isIdentical(a0, a1) {
+  if (!(0, _isArray["default"])(a0) || !(0, _isArray["default"])(a1)) {
+    throw new TypeError('Both of the arguments have to be an array!');
+  }
+
+  if (a0.length !== a1.length) {
+    return false;
+  }
+
+  for (var i = 0; i < a1.length; i++) {
+    if (a0[i] !== a1[i]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+exports.isIdentical = isIdentical;
+var _default = isIdentical;
+exports["default"] = _default;

package/Utils/Async/AsyncManager.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAsyncManager = void 0;
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); 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); } return keys; }
+
+function _objectSpread(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)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Manager that solves the problem of repeatable async calls to keep only the result for the last call
+ * New timestamp can be created with the create(args) function, which gets all the arguments
+ * that needed to be passed to the given asyncFunction
+ * The call() function throws an error if the result is "outdated" (there was a new call fired before we received it).
+ * @param {function} asyncFunction Any function that returns a Promise instance.
+ * @param {object} config The configuration object. Currently takes only the getKey function that identifies
+ * similar function calls to manage.
+ * @returns {{create: (function(*=))}}
+ */
+var createAsyncManager = function createAsyncManager(asyncFunction, config) {
+  var calls = {};
+
+  var _getKey$config = _objectSpread({
+    getKey: function getKey() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return JSON.stringify(args);
+    }
+  }, config),
+      getKey = _getKey$config.getKey;
+
+  var create = function create() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    var key = getKey.apply(void 0, args);
+    var time = Date.now();
+    calls[key] = time;
+
+    var validate = function validate() {
+      return calls[key] === time;
+    };
+
+    var isOutdated = function isOutdated() {
+      return !validate();
+    };
+
+    var call = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+        var error, response;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                error = null;
+                response = null;
+                _context.prev = 2;
+                _context.next = 5;
+                return asyncFunction.apply(void 0, args);
+
+              case 5:
+                response = _context.sent;
+                _context.next = 11;
+                break;
+
+              case 8:
+                _context.prev = 8;
+                _context.t0 = _context["catch"](2);
+                error = _context.t0;
+
+              case 11:
+                if (!isOutdated()) {
+                  _context.next = 14;
+                  break;
+                }
+
+                // eslint-disable-next-line no-console
+                console.warn('Outdated response, skipping handlers.', args);
+                throw new Error("Outdated response for the following request: ".concat(JSON.stringify(args)));
+
+              case 14:
+                if (!error) {
+                  _context.next = 16;
+                  break;
+                }
+
+                throw error;
+
+              case 16:
+                return _context.abrupt("return", response);
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[2, 8]]);
+      }));
+
+      return function call() {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    return {
+      call: call,
+      validate: validate,
+      isOutdated: isOutdated
+    };
+  };
+
+  return {
+    create: create
+  };
+};
+
+exports.createAsyncManager = createAsyncManager;