@configuratorware/configurator-frontendgui 1.28.6 → 1.29.3

package/App/Reducers/Configurator/Actions.js

@@ -0,0 +1,1417 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setSelectedCalculation = exports.switchSelectedAmount = exports.setComment = exports.deleteSelectedAmounts = exports.setSelectedAmounts = exports.deleteSelectedAmount = exports.clearBulkNames = exports.saveBulkNames = exports.setSelectedAmount = exports.loadDesignerData = exports.receiveDesignerData = exports.loadConfiguration = exports.viewOptionDetails = exports.selectMultipleOptions = exports.selectOption = exports.resolveConflicts = exports.loadInitialOptionclassification = exports.fetchInitialConfiguration = exports.setConflictingSwitchoptionData = exports.setOptionclassificationChecked = exports.setCalculationEnabled = exports.setSelectedVariantIdentifier = exports.setStockInformationOption = exports.setLoadIdentifier = exports.setLoadCode = exports.fetchInspirations = exports.fetchClientData = exports.fetchCodesnippets = exports.fetchConfigurationVariants = exports.validateConfiguration = exports.saveConfiguration = exports.fetchOptionDetails = exports.doCalculation = exports.switchOptions = exports.switchOptionArrays = exports.switchOptionsBasic = exports.fetchOptions = exports.fetchConfigurationByCodeAsync = exports.fetchConfigurationByCode = exports.fetchConfiguration = exports.inspectValidationResults = exports.inspectCheckResults = exports.setCustomTitle = exports.receiveInspirations = exports.receiveClientData = exports.fetchConfigurationForDesignerProductPreview = exports.receiveCodesnippets = exports.receiveConfigurationVariants = exports.receiveValidation = exports.receiveSavedConfiguration = exports.clearOptionDetails = exports.receiveOptionDetails = exports.skipNextAutoResolve = exports.setCalculationAutoResolveEnabled = exports.setCalculationErrorsResolved = exports.invalidateCalculation = exports.receiveCalculation = exports.receiveSwitchoptionsresult = exports.receiveOptions = exports.selectOptionclassification = exports.applyVariantAmountPreSelection = exports.setDefaultSelectedVariantIdentifier = exports.deleteMissingVariants = exports.receiveConfiguration = exports.DELETE_SELECTED_AMOUNTS = exports.SET_SELECTED_AMOUNTS = exports.SET_COMMENT = exports.SET_SELECTED_CALCULATION = exports.DELETE_SELECTED_AMOUNT = exports.CLEAR_BULKNAMES = exports.SAVE_BULKNAMES = exports.SWITCH_SELECTED_AMOUNT = exports.SET_SELECTED_AMOUNT = exports.SET_CONFLICTING_SWITCHOPTION_DATA = exports.SET_OPTIONCLASSIFICATION_CHECKED = exports.SET_CALCULATION_AUTO_RESOLVE_ENABLED = exports.SET_CALCULATION_ERRORS_RESOLVED = exports.SET_CALCULATION_ENABLED = exports.SET_SELECTED_VARIANT_IDENTIFIER = exports.SET_STOCK_INFORMATION_OPTION = exports.SET_LOAD_IDENTIFIER = exports.SET_LOAD_CODE = exports.SET_CUSTOM_TITLE = exports.RECEIVE_INSPIRATIONS = exports.RECEIVE_CLIENT_DATA = exports.RECEIVE_CODESNIPPETS = exports.RECEIVE_CONFIGURATIONVARIANTS = exports.RECEIVE_VALIDATION = exports.RECEIVE_SAVEDCONFIGURATION = exports.RECEIVE_OPTIONDETAILS = exports.INVALIDATE_CALCULATION = exports.RECEIVE_CALCULATION = exports.RECEIVE_SWITCHOPTIONSRESULT = exports.RECEIVE_OPTIONS = exports.SELECT_OPTIONCLASSIFICATION = exports.RECEIVE_DESIGNER_DATA = exports.RECEIVE_CONFIGURATION = void 0;
+
+var apiActions = _interopRequireWildcard(require("../Actions"));
+
+var _lodash = require("lodash");
+
+var _uniq = _interopRequireDefault(require("lodash/uniq"));
+
+var _i18n = require("../../../Framework/i18n");
+
+var _Api = _interopRequireDefault(require("../../../Framework/Api"));
+
+var _createActionWithGlobalState = require("../../../Utils/Redux/createActionWithGlobalState");
+
+var _configuration = require("../../configuration");
+
+var _ServiceLocator = require("../../ServiceLocator");
+
+var _Actions2 = require("../UI/Actions");
+
+var _Actions3 = require("../../Reducers/Fonts/Actions");
+
+var _Actions4 = require("../../Reducers/ImageGallery/Actions");
+
+var _Selectors = require("./Selectors");
+
+var _Selectors2 = require("../ConfigurationMode/Selectors");
+
+var _Constant = require("../../Constant");
+
+var _Selectors3 = require("../Fonts/Selectors");
+
+var _Actions5 = require("../Fonts/Actions");
+
+var _Modifiers = require("./Modifiers");
+
+var _Actions6 = require("../DesignData/Actions");
+
+var _Transformers = require("../DesignArea/Transformers");
+
+var _Reducer = require("../DesignData/Reducer");
+
+var _Actions7 = require("../ConfigurationMode/Actions");
+
+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; }
+
+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 _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); }
+
+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; }
+
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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 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); }); }; }
+
+var RECEIVE_CONFIGURATION = 'RECEIVE_CONFIGURATION';
+exports.RECEIVE_CONFIGURATION = RECEIVE_CONFIGURATION;
+var RECEIVE_DESIGNER_DATA = 'RECEIVE_DESIGNER_DATA';
+exports.RECEIVE_DESIGNER_DATA = RECEIVE_DESIGNER_DATA;
+var SELECT_OPTIONCLASSIFICATION = 'SELECT_OPTIONCLASSIFICATION';
+exports.SELECT_OPTIONCLASSIFICATION = SELECT_OPTIONCLASSIFICATION;
+var RECEIVE_OPTIONS = 'RECEIVE_OPTIONS';
+exports.RECEIVE_OPTIONS = RECEIVE_OPTIONS;
+var RECEIVE_SWITCHOPTIONSRESULT = 'RECEIVE_SWITCHOPTIONSRESULT';
+exports.RECEIVE_SWITCHOPTIONSRESULT = RECEIVE_SWITCHOPTIONSRESULT;
+var RECEIVE_CALCULATION = 'RECEIVE_CALCULATION';
+exports.RECEIVE_CALCULATION = RECEIVE_CALCULATION;
+var INVALIDATE_CALCULATION = 'INVALIDATE_CALCULATION';
+exports.INVALIDATE_CALCULATION = INVALIDATE_CALCULATION;
+var RECEIVE_OPTIONDETAILS = 'RECEIVE_OPTIONDETAILS';
+exports.RECEIVE_OPTIONDETAILS = RECEIVE_OPTIONDETAILS;
+var RECEIVE_SAVEDCONFIGURATION = 'RECEIVE_SAVEDCONFIGURATION';
+exports.RECEIVE_SAVEDCONFIGURATION = RECEIVE_SAVEDCONFIGURATION;
+var RECEIVE_VALIDATION = 'RECEIVE_VALIDATION';
+exports.RECEIVE_VALIDATION = RECEIVE_VALIDATION;
+var RECEIVE_CONFIGURATIONVARIANTS = 'RECEIVE_CONFIGURATIONVARIANTS';
+exports.RECEIVE_CONFIGURATIONVARIANTS = RECEIVE_CONFIGURATIONVARIANTS;
+var RECEIVE_CODESNIPPETS = 'RECEIVE_CODESNIPPETS';
+exports.RECEIVE_CODESNIPPETS = RECEIVE_CODESNIPPETS;
+var RECEIVE_CLIENT_DATA = 'RECEIVE_CLIENT_DATA';
+exports.RECEIVE_CLIENT_DATA = RECEIVE_CLIENT_DATA;
+var RECEIVE_INSPIRATIONS = 'RECEIVE_INSPIRATIONS';
+exports.RECEIVE_INSPIRATIONS = RECEIVE_INSPIRATIONS;
+var SET_CUSTOM_TITLE = 'SET_CUSTOM_TITLE';
+exports.SET_CUSTOM_TITLE = SET_CUSTOM_TITLE;
+var SET_LOAD_CODE = 'SET_LOAD_CODE';
+exports.SET_LOAD_CODE = SET_LOAD_CODE;
+var SET_LOAD_IDENTIFIER = 'SET_LOAD_IDENTIFIER';
+exports.SET_LOAD_IDENTIFIER = SET_LOAD_IDENTIFIER;
+var SET_STOCK_INFORMATION_OPTION = 'SET_STOCK_INFORMATION_OPTION';
+exports.SET_STOCK_INFORMATION_OPTION = SET_STOCK_INFORMATION_OPTION;
+var SET_SELECTED_VARIANT_IDENTIFIER = 'SET_SELECTED_VARIANT_IDENTIFIER';
+exports.SET_SELECTED_VARIANT_IDENTIFIER = SET_SELECTED_VARIANT_IDENTIFIER;
+var SET_CALCULATION_ENABLED = 'SET_CALCULATION_ENABLED';
+exports.SET_CALCULATION_ENABLED = SET_CALCULATION_ENABLED;
+var SET_CALCULATION_ERRORS_RESOLVED = 'SET_CALCULATION_ERRORS_RESOLVED';
+exports.SET_CALCULATION_ERRORS_RESOLVED = SET_CALCULATION_ERRORS_RESOLVED;
+var SET_CALCULATION_AUTO_RESOLVE_ENABLED = 'SET_CALCULATION_AUTO_RESOLVE_ENABLED';
+exports.SET_CALCULATION_AUTO_RESOLVE_ENABLED = SET_CALCULATION_AUTO_RESOLVE_ENABLED;
+var SET_OPTIONCLASSIFICATION_CHECKED = 'SET_OPTIONCLASSIFICATION_CHECKED';
+exports.SET_OPTIONCLASSIFICATION_CHECKED = SET_OPTIONCLASSIFICATION_CHECKED;
+var SET_CONFLICTING_SWITCHOPTION_DATA = 'SET_CONFLICTING_SWITCHOPTION_DATA';
+exports.SET_CONFLICTING_SWITCHOPTION_DATA = SET_CONFLICTING_SWITCHOPTION_DATA;
+var SET_SELECTED_AMOUNT = 'SET_SELECTED_AMOUNT';
+exports.SET_SELECTED_AMOUNT = SET_SELECTED_AMOUNT;
+var SWITCH_SELECTED_AMOUNT = 'SWITCH_SELECTED_AMOUNT';
+exports.SWITCH_SELECTED_AMOUNT = SWITCH_SELECTED_AMOUNT;
+var SAVE_BULKNAMES = 'SAVE_BULKNAMES';
+exports.SAVE_BULKNAMES = SAVE_BULKNAMES;
+var CLEAR_BULKNAMES = 'CLEAR_BULKNAMES';
+exports.CLEAR_BULKNAMES = CLEAR_BULKNAMES;
+var DELETE_SELECTED_AMOUNT = 'DELETE_SELECTED_AMOUNT';
+exports.DELETE_SELECTED_AMOUNT = DELETE_SELECTED_AMOUNT;
+var SET_SELECTED_CALCULATION = 'SET_SELECTED_CALCULATION';
+exports.SET_SELECTED_CALCULATION = SET_SELECTED_CALCULATION;
+var SET_COMMENT = 'SET_COMMENT';
+exports.SET_COMMENT = SET_COMMENT;
+var SET_SELECTED_AMOUNTS = 'SET_SELECTED_AMOUNTS';
+exports.SET_SELECTED_AMOUNTS = SET_SELECTED_AMOUNTS;
+var DELETE_SELECTED_AMOUNTS = 'DELETE_SELECTED_AMOUNTS';
+exports.DELETE_SELECTED_AMOUNTS = DELETE_SELECTED_AMOUNTS;
+
+var receiveConfiguration = function receiveConfiguration(json, _ref) {
+  var checkValidation = _ref.checkValidation;
+  return /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(dispatch, getState) {
+      var prevState, selectOptions, action, _getState, configurator, configuration, selectedoptionclassification, loadIdentifier, _getAvailableConfigur, designerEnabled, initialDesignData;
+
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              prevState = getState();
+              selectOptions = (0, _configuration.getConf)('selectOptions');
+              dispatch(setCalculationEnabled(false));
+
+              if (checkValidation) {
+                dispatch(inspectValidationResults(json));
+              }
+
+              action = dispatch({
+                type: RECEIVE_CONFIGURATION,
+                data: (0, _Modifiers.patchViewImages)(json),
+                receivedAt: Date.now()
+              });
+
+              if (selectOptions) {
+                dispatch(selectMultipleOptions(selectOptions));
+              }
+
+              dispatch(inspectCheckResults());
+              _getState = getState(), configurator = _getState.configurator;
+              configuration = configurator.configuration, selectedoptionclassification = configurator.selectedoptionclassification, loadIdentifier = configurator.loadIdentifier;
+              _getAvailableConfigur = (0, _Selectors2.getAvailableConfigurationModes)(getState()), designerEnabled = _getAvailableConfigur.designer;
+
+              if (configurator.loadCode) {
+                dispatch((0, _Actions4.addImagesFromDesignArea)(configurator));
+              }
+
+              dispatch(deleteMissingVariants(configurator)); // load first optionclassification if not selected yet
+
+              if (!selectedoptionclassification.identifier && (0, _configuration.getConf)('showInitialOptionclassification')) {
+                dispatch(loadInitialOptionclassification(configuration));
+              }
+
+              if ((0, _configuration.getConf)('loadInspirations')) {
+                dispatch(fetchInspirations(configuration.item.identifier));
+              }
+
+              dispatch((0, _Actions2.setVisible)('configurationvariantSelection', false));
+
+              if (prevState.configurator.configuration.item.identifier && prevState.configurator.configuration.item.identifier !== configuration.item.identifier) {
+                dispatch(fetchConfigurationVariants(configuration.item.identifier));
+              }
+
+              applyVariantAmountPreSelection(configurator);
+              setDefaultSelectedVariantIdentifier((0, _Selectors.getConfigurator)(getState()), loadIdentifier);
+
+              if (!designerEnabled) {
+                _context.next = 26;
+                break;
+              }
+
+              _context.next = 21;
+              return dispatch((0, _Actions3.fetchFonts)());
+
+            case 21:
+              dispatch((0, _Actions5.addCustomFonts)((0, _Selectors3.getUsedCustomFontsInEditor)(getState())));
+              _context.next = 24;
+              return dispatch(loadDesignerData((0, _Selectors.getConfiguration)((0, _Selectors.getConfigurator)(getState()))));
+
+            case 24:
+              initialDesignData = (0, _Transformers.createInitialDesignDataFromDesignAreas)((0, _lodash.get)(getState(), 'designArea.filteredDesignAreas') || [], (0, _Reducer.getDesignData)((0, _Selectors.getConfigurator)(getState())));
+              dispatch((0, _Actions6.setInitialDesignData)(initialDesignData));
+
+            case 26:
+              // enable calculation and trigger it
+              dispatch(setCalculationEnabled(true));
+              dispatch(invalidateCalculation());
+              dispatch(doCalculation((0, _Selectors.getConfiguration)((0, _Selectors.getConfigurator)(getState()))));
+              return _context.abrupt("return", action);
+
+            case 30:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};
+
+exports.receiveConfiguration = receiveConfiguration;
+
+var deleteMissingVariants = function deleteMissingVariants(configurator) {
+  return /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(dispatch) {
+      var children, selectedAmounts, item, result, itemGroupChildren, _iterator, _step, itemGroup, flattenendSubChildren, selectedVariant;
+
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              children = (0, _Selectors.getChildren)(configurator).map(function (variant) {
+                return variant.identifier;
+              });
+              selectedAmounts = (0, _Selectors.getSelectedAmounts)(configurator);
+              item = (0, _lodash.get)(configurator, 'configuration.item');
+              result = [];
+              itemGroupChildren = (0, _lodash.get)(item, 'itemGroup.children', []);
+
+              if (itemGroupChildren.length > 0) {
+                _iterator = _createForOfIteratorHelper(item.itemGroup.children);
+
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    itemGroup = _step.value;
+                    result.push(Object.values((0, _Selectors.getDeepestChildIdentifiers)(itemGroup)));
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+              } else {
+                result.push(item.identifier);
+              }
+
+              flattenendSubChildren = (0, _lodash.flatten)(result);
+              _context2.t0 = regeneratorRuntime.keys(selectedAmounts);
+
+            case 8:
+              if ((_context2.t1 = _context2.t0()).done) {
+                _context2.next = 15;
+                break;
+              }
+
+              selectedVariant = _context2.t1.value;
+
+              if (selectedAmounts.hasOwnProperty(selectedVariant)) {
+                _context2.next = 12;
+                break;
+              }
+
+              return _context2.abrupt("continue", 8);
+
+            case 12:
+              if (children.length !== 0 && children.indexOf(selectedVariant) === -1 && flattenendSubChildren.indexOf(selectedVariant) === -1) {
+                dispatch(deleteSelectedAmount(selectedVariant));
+                dispatch((0, _Actions2.reportError)((0, _i18n.t)('missingVariantError', {
+                  selectedVariant: selectedVariant
+                })));
+              }
+
+              _context2.next = 8;
+              break;
+
+            case 15:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x3) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+};
+
+exports.deleteMissingVariants = deleteMissingVariants;
+
+var setDefaultSelectedVariantIdentifier = function setDefaultSelectedVariantIdentifier(configurator, loadIdentifier) {
+  var variantChildren = (0, _Selectors.getChildren)(configurator).map(function (variant) {
+    return variant.itemGroup ? variant.itemGroup.children : variant;
+  });
+  var children = (0, _uniq["default"])((0, _lodash.flatten)(variantChildren).map(function (child) {
+    return child.identifier;
+  }));
+  var firstSelectedAmountEntry = (0, _lodash.first)(Object.keys((0, _Selectors.getSelectedAmounts)(configurator)));
+  var item = (0, _Selectors.getItem)(configurator);
+  var selectedVariant = children.length ? children[0] : null;
+
+  if (children.indexOf(loadIdentifier) !== -1) {
+    selectedVariant = loadIdentifier;
+  } else if (firstSelectedAmountEntry) {
+    selectedVariant = firstSelectedAmountEntry;
+  } else {
+    selectedVariant = item.identifier;
+  }
+
+  _ServiceLocator.Services.configurator.setSelectedVariantIdentifier(selectedVariant);
+};
+
+exports.setDefaultSelectedVariantIdentifier = setDefaultSelectedVariantIdentifier;
+
+var applyVariantAmountPreSelection = function applyVariantAmountPreSelection(configurator) {
+  var designerPreSelection = (0, _configuration.getConf)('designerPreSelection', {});
+  var itemAmounts = designerPreSelection.itemAmounts;
+
+  if (itemAmounts) {
+    var children = (0, _Selectors.getChildren)(configurator).map(function (variant) {
+      return variant.identifier;
+    });
+
+    for (var preSelectionVariant in itemAmounts) {
+      if (!itemAmounts.hasOwnProperty(preSelectionVariant)) {
+        continue;
+      }
+
+      var amount = +itemAmounts[preSelectionVariant];
+
+      if (children.indexOf(preSelectionVariant) !== -1 && amount > 0) {
+        _ServiceLocator.Services.configurator.setSelectedAmount(preSelectionVariant, amount);
+      }
+    }
+  }
+};
+
+exports.applyVariantAmountPreSelection = applyVariantAmountPreSelection;
+
+var selectOptionclassification = function selectOptionclassification(optionclassification) {
+  var triggerFetchOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var showOptionlist = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return function (dispatch, getState) {
+    if (getState().ui.visibilityMap.startHere) {
+      dispatch((0, _Actions2.setVisible)('startHere', false));
+    }
+
+    var action = dispatch({
+      type: SELECT_OPTIONCLASSIFICATION,
+      optionclassification: optionclassification
+    });
+    var configuration = getState().configurator.configuration;
+
+    if (triggerFetchOptions) {
+      _ServiceLocator.Services.analytics.triggerEvent(_Constant.EventTypes['select_component'], optionclassification.identifier);
+
+      _ServiceLocator.Services.configurator.loadOptions(configuration.item.identifier, optionclassification.identifier, configuration);
+    }
+
+    dispatch((0, _Actions2.setVisible)('optionlist', showOptionlist));
+    return action;
+  };
+};
+
+exports.selectOptionclassification = selectOptionclassification;
+
+var receiveOptions = function receiveOptions(json, extraData) {
+  return function (dispatch, getState) {
+    // it should wait until the options are loaded for the optionclassification...
+    var optionclassification = extraData.optionclassification; // make sure the received option list belongs to the selected optionclassification,
+    // it might have changed since the request was sent
+
+    if (optionclassification === getState().configurator.selectedoptionclassification.identifier) {
+      if ((0, _configuration.getConf)('checkOptionclassificationOnSelect')) {
+        dispatch(setOptionclassificationChecked(optionclassification));
+      }
+
+      return dispatch({
+        type: RECEIVE_OPTIONS,
+        data: json,
+        receivedAt: Date.now()
+      });
+    }
+  };
+};
+
+exports.receiveOptions = receiveOptions;
+
+var receiveSwitchoptionsresult = function receiveSwitchoptionsresult(json, extraData) {
+  return function (dispatch, getState) {
+    var switchOptionData = extraData.switchOptionData,
+        noCheck = extraData.noCheck,
+        setChecked = extraData.setChecked,
+        refreshOptions = extraData.refreshOptions;
+    var action = dispatch({
+      type: RECEIVE_SWITCHOPTIONSRESULT,
+      data: (0, _Modifiers.patchViewImages)(json),
+      receivedAt: Date.now()
+    });
+
+    var _getState2 = getState(),
+        configurator = _getState2.configurator;
+
+    var configuration = configurator.configuration,
+        selectedoptionclassification = configurator.selectedoptionclassification; // if it was sent with noCheck param, there is nothing to do with the check results..
+    // it should be a temporary configuration state
+
+    if (noCheck) {
+      return action;
+    }
+
+    var checkResultOk = dispatch(inspectCheckResults());
+
+    if (checkResultOk) {
+      if (setChecked) {
+        dispatch(setOptionclassificationChecked((0, _lodash.first)(Object.keys(switchOptionData))));
+      } // do it only when there is a selected option classification
+
+
+      if (refreshOptions && selectedoptionclassification) {
+        _ServiceLocator.Services.configurator.loadOptions(configuration.item.identifier, selectedoptionclassification.identifier, configuration);
+      }
+    } else {
+      dispatch(setConflictingSwitchoptionData(switchOptionData));
+    }
+
+    return action;
+  };
+};
+
+exports.receiveSwitchoptionsresult = receiveSwitchoptionsresult;
+
+var receiveCalculation = function receiveCalculation(json) {
+  return {
+    type: RECEIVE_CALCULATION,
+    data: json,
+    receivedAt: Date.now()
+  };
+};
+
+exports.receiveCalculation = receiveCalculation;
+
+var invalidateCalculation = function invalidateCalculation() {
+  return {
+    type: INVALIDATE_CALCULATION
+  };
+};
+
+exports.invalidateCalculation = invalidateCalculation;
+
+var setCalculationErrorsResolved = function setCalculationErrorsResolved() {
+  return {
+    type: SET_CALCULATION_ERRORS_RESOLVED
+  };
+};
+
+exports.setCalculationErrorsResolved = setCalculationErrorsResolved;
+
+var setCalculationAutoResolveEnabled = function setCalculationAutoResolveEnabled(enabled) {
+  return {
+    type: SET_CALCULATION_AUTO_RESOLVE_ENABLED,
+    enabled: enabled
+  };
+};
+
+exports.setCalculationAutoResolveEnabled = setCalculationAutoResolveEnabled;
+
+var skipNextAutoResolve = function skipNextAutoResolve() {
+  return setCalculationAutoResolveEnabled('skipNext');
+};
+
+exports.skipNextAutoResolve = skipNextAutoResolve;
+
+var receiveOptionDetails = function receiveOptionDetails(json) {
+  return function (dispatch) {
+    dispatch((0, _Actions2.setVisible)('optionDetails', true));
+    return dispatch({
+      type: RECEIVE_OPTIONDETAILS,
+      data: json,
+      receivedAt: Date.now()
+    });
+  };
+};
+
+exports.receiveOptionDetails = receiveOptionDetails;
+
+var clearOptionDetails = function clearOptionDetails() {
+  return {
+    type: RECEIVE_OPTIONDETAILS,
+    data: {},
+    receivedAt: Date.now()
+  };
+};
+
+exports.clearOptionDetails = clearOptionDetails;
+
+var receiveSavedConfiguration = function receiveSavedConfiguration(json) {
+  return {
+    type: RECEIVE_SAVEDCONFIGURATION,
+    data: (0, _Modifiers.patchViewImages)(json),
+    receivedAt: Date.now()
+  };
+};
+
+exports.receiveSavedConfiguration = receiveSavedConfiguration;
+
+var receiveValidation = function receiveValidation(json) {
+  return function (dispatch, getState) {
+    var action = dispatch({
+      type: RECEIVE_VALIDATION,
+      data: json,
+      receivedAt: Date.now()
+    });
+    var validationResult = getState().configurator.validation;
+
+    if ((0, _lodash.isObject)(validationResult) && validationResult.success === false) {
+      dispatch((0, _Actions2.setVisible)('validationResult', true));
+      throw 'Invalid configuration!';
+    }
+
+    return action;
+  };
+};
+
+exports.receiveValidation = receiveValidation;
+
+var receiveConfigurationVariants = function receiveConfigurationVariants(json) {
+  return {
+    type: RECEIVE_CONFIGURATIONVARIANTS,
+    data: json,
+    receivedAt: Date.now()
+  };
+};
+
+exports.receiveConfigurationVariants = receiveConfigurationVariants;
+
+var receiveCodesnippets = function receiveCodesnippets(json) {
+  return {
+    type: RECEIVE_CODESNIPPETS,
+    data: json,
+    receivedAt: Date.now()
+  };
+};
+
+exports.receiveCodesnippets = receiveCodesnippets;
+
+var fetchConfigurationForDesignerProductPreview = function fetchConfigurationForDesignerProductPreview() {
+  return /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(dispatch, getState) {
+      var itemIdentifier, _getAvailableConfigur2, designerEnabled, initialDesignData;
+
+      return regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              itemIdentifier = getState().configurator.loadIdentifier;
+              dispatch(setCalculationEnabled(false));
+              _context3.next = 4;
+              return dispatch(apiActions.fetchData('configuration/loadbyitemidentifier/' + itemIdentifier, function (json) {
+                return {
+                  type: RECEIVE_CONFIGURATION,
+                  data: (0, _Modifiers.patchViewImages)(json),
+                  receivedAt: Date.now()
+                };
+              }));
+
+            case 4:
+              setDefaultSelectedVariantIdentifier((0, _Selectors.getConfigurator)(getState()), itemIdentifier);
+              _getAvailableConfigur2 = (0, _Selectors2.getAvailableConfigurationModes)(getState()), designerEnabled = _getAvailableConfigur2.designer;
+
+              if (!designerEnabled) {
+                _context3.next = 12;
+                break;
+              }
+
+              dispatch((0, _Actions7.selectConfigurationMode)('designer'));
+              _context3.next = 10;
+              return dispatch(loadDesignerData((0, _Selectors.getConfiguration)((0, _Selectors.getConfigurator)(getState()))));
+
+            case 10:
+              initialDesignData = (0, _Transformers.createInitialDesignDataFromDesignAreas)((0, _lodash.get)(getState(), 'designArea.filteredDesignAreas') || [], (0, _Reducer.getDesignData)((0, _Selectors.getConfigurator)(getState())));
+              dispatch((0, _Actions6.setInitialDesignData)(initialDesignData));
+
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    return function (_x4, _x5) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+};
+
+exports.fetchConfigurationForDesignerProductPreview = fetchConfigurationForDesignerProductPreview;
+
+var receiveClientData = function receiveClientData(json) {
+  return function (dispatch, getState) {
+    dispatch({
+      type: RECEIVE_CLIENT_DATA,
+      data: json,
+      receivedAt: Date.now()
+    });
+
+    if (json.success === false) {
+      return dispatch((0, _Actions2.reportError)((0, _i18n.t)('clientValidationError')));
+    }
+
+    var client = (0, _Selectors.getClient)(getState().configurator);
+
+    _Api["default"].setChannel(client.channel);
+
+    var requests = [];
+
+    if ((0, _Selectors.isDesignerProductPreviewMode)()) {// initial configuration is not needed
+    } else {
+      requests.push(_ServiceLocator.Services.configurator.loadInitialConfiguration());
+    }
+
+    requests.push(_ServiceLocator.Services.configurator.loadCodeSnippets());
+    return Promise.all(requests);
+  };
+};
+
+exports.receiveClientData = receiveClientData;
+
+var receiveInspirations = function receiveInspirations(json) {
+  return {
+    type: RECEIVE_INSPIRATIONS,
+    data: json
+  };
+};
+
+exports.receiveInspirations = receiveInspirations;
+
+var setCustomTitle = function setCustomTitle(title) {
+  return {
+    type: SET_CUSTOM_TITLE,
+    title: title
+  };
+};
+
+exports.setCustomTitle = setCustomTitle;
+
+var inspectCheckResults = function inspectCheckResults() {
+  return function (dispatch, getState) {
+    var _getState3 = getState(),
+        ui = _getState3.ui,
+        configurator = _getState3.configurator;
+
+    var configuration = configurator.configuration;
+
+    if ((0, _lodash.isObject)(configuration.check_results)) {
+      if (configuration.check_results.status) {
+        if (ui.visibilityMap.incompatibility) {
+          dispatch((0, _Actions2.setVisible)('incompatibility', false));
+        }
+
+        return true;
+      } else {
+        dispatch((0, _Actions2.setVisible)('incompatibility', true));
+        return false;
+      }
+    }
+
+    return true;
+  };
+};
+
+exports.inspectCheckResults = inspectCheckResults;
+
+var inspectValidationResults = function inspectValidationResults(configuration) {
+  return function (dispatch) {
+    var validationResult = (0, _lodash.get)(configuration, 'information.validation_result');
+
+    if ((0, _lodash.isObject)(validationResult) && validationResult.success === false) {
+      dispatch((0, _Actions2.setVisible)('validationResult', true));
+    }
+  };
+};
+
+exports.inspectValidationResults = inspectValidationResults;
+
+var fetchConfiguration = function fetchConfiguration(itemidentifier) {
+  return apiActions.fetchData('configuration/loadbyitemidentifier/' + itemidentifier, receiveConfiguration);
+};
+
+exports.fetchConfiguration = fetchConfiguration;
+
+var fetchConfigurationByCode = function fetchConfigurationByCode(code) {
+  var checkValidation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return apiActions.fetchData('configuration/loadbyconfigurationcode/' + code, receiveConfiguration, {
+    checkValidation: checkValidation
+  });
+};
+
+exports.fetchConfigurationByCode = fetchConfigurationByCode;
+
+var fetchConfigurationByCodeAsync = function fetchConfigurationByCodeAsync(code) {
+  var checkValidation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return apiActions.fetchDataAsync('configuration/loadbyconfigurationcode/' + code, receiveConfiguration, {
+    checkValidation: checkValidation
+  });
+};
+
+exports.fetchConfigurationByCodeAsync = fetchConfigurationByCodeAsync;
+
+var fetchOptions = function fetchOptions(itemidentifier, optionclassification, configuration) {
+  return apiActions.postData('options/list/' + itemidentifier + '/' + optionclassification, {
+    configuration: configuration
+  }, receiveOptions, {}, // config
+  {
+    optionclassification: optionclassification
+  } // extraData
+  );
+};
+
+exports.fetchOptions = fetchOptions;
+
+var switchOptionsBasic = function switchOptionsBasic(configuration, switchedoptions) {
+  var noCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var config = {};
+
+  if (noCheck) {
+    config.params = {
+      nocheck: 1
+    };
+  }
+
+  return apiActions.postData('configuration/switchoption', {
+    configuration: configuration,
+    switchedoptions: switchedoptions
+  }, function (data) {
+    return {
+      // dummy receiver
+      type: 'RECEIVE_SWITCHOPTIONSRESULT_BASIC',
+      data: data
+    };
+  }, config);
+};
+
+exports.switchOptionsBasic = switchOptionsBasic;
+
+var switchOptionArrays = function switchOptionArrays(configuration, switchOptionData) {
+  var noCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return function (dispatch) {
+    var switchedoptions = {};
+    var afterSwitch = [];
+
+    for (var componentIdentifier in switchOptionData) {
+      if ((0, _lodash.isArray)(switchOptionData[componentIdentifier])) {
+        var _switchOptionData$com = _toArray(switchOptionData[componentIdentifier]),
+            firstOption = _switchOptionData$com[0],
+            otherOptions = _switchOptionData$com.slice(1);
+
+        switchedoptions[componentIdentifier] = firstOption;
+
+        if (otherOptions.length > 0) {
+          var _iterator2 = _createForOfIteratorHelper(otherOptions),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var optionData = _step2.value;
+              afterSwitch.push(_defineProperty({}, componentIdentifier, optionData));
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } else {
+        switchedoptions[componentIdentifier] = switchOptionData[componentIdentifier];
+      }
+    }
+
+    var p = dispatch(switchOptionsBasic(configuration, switchedoptions, noCheck));
+
+    var _loop = function _loop() {
+      var switchOption = _afterSwitch[_i];
+      p = p.then(function (action) {
+        return dispatch(switchOptionsBasic(action.data, switchOption, noCheck));
+      });
+    };
+
+    for (var _i = 0, _afterSwitch = afterSwitch; _i < _afterSwitch.length; _i++) {
+      _loop();
+    }
+
+    return p;
+  };
+};
+
+exports.switchOptionArrays = switchOptionArrays;
+
+var switchOptions = function switchOptions(configuration, switchOptionData) {
+  var noCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var refreshOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var setChecked = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  return function (dispatch) {
+    return dispatch(switchOptionArrays(configuration, switchOptionData, noCheck)).then(function (action) {
+      var extraData = {
+        switchOptionData: switchOptionData,
+        noCheck: noCheck,
+        refreshOptions: refreshOptions,
+        setChecked: setChecked
+      };
+      return dispatch(receiveSwitchoptionsresult(action.data, extraData));
+    });
+  };
+};
+
+exports.switchOptions = switchOptions;
+
+var doCalculation = function doCalculation() {
+  return function (dispatch, getState) {
+    var configuration = (0, _Selectors.getConfiguration)((0, _Selectors.getConfigurator)(getState()));
+    return dispatch(apiActions.postDataAsync('calculation', configuration, receiveCalculation));
+  };
+};
+
+exports.doCalculation = doCalculation;
+
+var fetchOptionDetails = function fetchOptionDetails(optionidentifier, configuration) {
+  return apiActions.postData('options/detail/' + optionidentifier, {
+    configuration: configuration
+  }, receiveOptionDetails);
+};
+
+exports.fetchOptionDetails = fetchOptionDetails;
+
+var saveConfiguration = function saveConfiguration(configuration, configurationtype) {
+  return apiActions.postDataAsync('configurations', {
+    configuration: configuration,
+    configurationtype: configurationtype
+  }, receiveSavedConfiguration);
+};
+
+exports.saveConfiguration = saveConfiguration;
+
+var validateConfiguration = function validateConfiguration(configuration) {
+  return apiActions.postData('configuration/validate', {
+    configuration: configuration
+  }, receiveValidation);
+};
+
+exports.validateConfiguration = validateConfiguration;
+
+var fetchConfigurationVariants = function fetchConfigurationVariants(itemidentifier) {
+  return apiActions.fetchData('items/getconfigurationvariants/' + itemidentifier, receiveConfigurationVariants);
+};
+
+exports.fetchConfigurationVariants = fetchConfigurationVariants;
+
+var fetchCodesnippets = function fetchCodesnippets() {
+  return apiActions.fetchData('codesnippets/getcurrent', receiveCodesnippets);
+};
+
+exports.fetchCodesnippets = fetchCodesnippets;
+
+var fetchClientData = function fetchClientData() {
+  return apiActions.fetchData('client', receiveClientData);
+};
+
+exports.fetchClientData = fetchClientData;
+
+var fetchInspirations = function fetchInspirations(itemidentifier) {
+  return apiActions.fetchData('inspirations/' + itemidentifier, receiveInspirations);
+};
+
+exports.fetchInspirations = fetchInspirations;
+
+var setLoadCode = function setLoadCode() {
+  var loadCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  return {
+    type: SET_LOAD_CODE,
+    loadCode: loadCode
+  };
+};
+
+exports.setLoadCode = setLoadCode;
+
+var setLoadIdentifier = function setLoadIdentifier(loadIdentifier) {
+  return {
+    type: SET_LOAD_IDENTIFIER,
+    loadIdentifier: loadIdentifier
+  };
+};
+
+exports.setLoadIdentifier = setLoadIdentifier;
+
+var setStockInformationOption = function setStockInformationOption(option) {
+  return {
+    type: SET_STOCK_INFORMATION_OPTION,
+    stockInformationOption: option
+  };
+};
+
+exports.setStockInformationOption = setStockInformationOption;
+
+var setSelectedVariantIdentifier = function setSelectedVariantIdentifier(identifier) {
+  return {
+    type: SET_SELECTED_VARIANT_IDENTIFIER,
+    selectedVariantIdentifier: identifier
+  };
+};
+
+exports.setSelectedVariantIdentifier = setSelectedVariantIdentifier;
+
+var setCalculationEnabled = function setCalculationEnabled(enabled) {
+  return {
+    type: SET_CALCULATION_ENABLED,
+    enabled: enabled
+  };
+};
+
+exports.setCalculationEnabled = setCalculationEnabled;
+
+var setOptionclassificationChecked = function setOptionclassificationChecked(optionclassification) {
+  return function (dispatch, getState) {
+    if (_typeof(optionclassification) !== 'object') {
+      optionclassification = find(getState().configurator.configuration.optionclassifications, {
+        identifier: optionclassification
+      });
+    }
+
+    if (!getState().configurator.checkedOptionclassifications[optionclassification.identifier]) {
+      return dispatch({
+        type: SET_OPTIONCLASSIFICATION_CHECKED,
+        optionclassification: optionclassification
+      });
+    }
+  };
+};
+
+exports.setOptionclassificationChecked = setOptionclassificationChecked;
+
+var setConflictingSwitchoptionData = function setConflictingSwitchoptionData(switchOptionData) {
+  return {
+    type: SET_CONFLICTING_SWITCHOPTION_DATA,
+    switchOptionData: switchOptionData
+  };
+};
+
+exports.setConflictingSwitchoptionData = setConflictingSwitchoptionData;
+
+var fetchInitialConfiguration = function fetchInitialConfiguration() {
+  return function (dispatch, getState) {
+    var _getState$configurato = getState().configurator,
+        loadCode = _getState$configurato.loadCode,
+        loadIdentifier = _getState$configurato.loadIdentifier;
+    var defaultLoadIdentifier = (0, _configuration.getConf)('defaultLoadIdentifier');
+
+    if (loadCode) {
+      // Load the configuration by code
+      return dispatch(fetchConfigurationByCode(loadCode)).then(function (configuration) {
+        if (configuration.error) {
+          dispatch((0, _Actions2.reportConfigurationNotFoundError)((0, _i18n.t)('loadConfiguration.error.loadingFailed')));
+        } else {
+          _ServiceLocator.Services.analytics.triggerEvent(_Constant.EventTypes.load_item, configuration.data.item.identifier);
+        }
+      });
+    } else if ((0, _configuration.getConf)('loadVariantsFirst')) {
+      // Load variants by identifier
+      dispatch((0, _Actions2.setVisible)('configurationvariantSelection', true));
+      return dispatch(fetchConfigurationVariants(loadIdentifier)).then(function (result) {
+        // if the result contains error just return, do nothing else
+        if (result.error) {
+          return;
+        }
+
+        var _getState$configurato2 = getState().configurator,
+            configurationvariants = _getState$configurato2.configurationvariants,
+            loadIdentifier = _getState$configurato2.loadIdentifier; // If there is only one variant or the list is empty, fall back to fetchConfiguration
+
+        if ((0, _lodash.isArray)(configurationvariants)) {
+          if (configurationvariants.length === 0) {
+            // Load the options for the initially selected optionclassification
+            dispatch(fetchConfiguration(loadIdentifier));
+          }
+
+          if (configurationvariants.length === 1) {
+            // There is only one variant in the list, just load it
+            dispatch(fetchConfiguration(configurationvariants[0].identifier));
+          }
+        }
+      });
+    } else if (loadIdentifier === '__empty__') {
+      return Promise.resolve();
+    } else if (loadIdentifier) {
+      return dispatch(fetchConfiguration(loadIdentifier));
+    } else if (defaultLoadIdentifier) {
+      return dispatch(fetchConfiguration(defaultLoadIdentifier));
+    }
+  };
+};
+
+exports.fetchInitialConfiguration = fetchInitialConfiguration;
+
+var loadInitialOptionclassification = function loadInitialOptionclassification(configuration) {
+  return function (dispatch) {
+    var identifier = configuration.item.identifier;
+    var optionclassification = (0, _lodash.get)(configuration, 'optionclassifications[0]');
+    dispatch(selectOptionclassification(optionclassification));
+
+    _ServiceLocator.Services.configurator.loadOptions(identifier, optionclassification.identifier, configuration);
+
+    dispatch((0, _Actions2.setVisible)('optionlist', true));
+  };
+};
+
+exports.loadInitialOptionclassification = loadInitialOptionclassification;
+
+var resolveConflicts = function resolveConflicts() {
+  return function (dispatch, getState) {
+    var _getState4 = getState(),
+        configurator = _getState4.configurator;
+
+    var configuration = configurator.configuration;
+    var incompatibilityCheckResults = configuration.check_results;
+    var p = false;
+
+    if ((0, _lodash.isArray)(incompatibilityCheckResults.check_results)) {
+      dispatch(setCalculationEnabled(false)); // disable calculation while waiting for all options to be switched
+
+      var _iterator3 = _createForOfIteratorHelper(incompatibilityCheckResults.check_results),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var result = _step3.value;
+
+          if (result.status === false) {
+            (function () {
+              // check for data to perform automated option switching
+              var switchOptionsData = (0, _lodash.get)(result, 'data.switchOptions');
+
+              if (switchOptionsData) {
+                if (p) {
+                  p = p.then(function (action) {
+                    return dispatch(switchOptionArrays(action.data, switchOptionsData, true));
+                  });
+                } else {
+                  p = dispatch(switchOptionArrays(configuration, switchOptionsData, true));
+                }
+              }
+            })();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      if (p) {
+        p = p.then(function (action) {
+          // after all conflicts resolved, the desired option can be set
+          var conflictingSwitchOptionData = getState().configurator.conflictingSwitchOptionData;
+          return dispatch(switchOptions(action.data, conflictingSwitchOptionData, false, true, true));
+        }).then(function (action) {
+          if ((0, _lodash.get)(action, 'data.check_results.status') === false) {
+            throw 'There are new conflicts..';
+          }
+
+          var configuration = getState().configurator.configuration; // enable calculation and refresh it
+
+          dispatch(setCalculationEnabled(true));
+          dispatch(invalidateCalculation());
+          dispatch(doCalculation(configuration)); // hide the incompatibility dialog
+
+          dispatch((0, _Actions2.setVisible)('incompatibility', false));
+          return action;
+        })["catch"](function (e) {
+          // eslint-disable-next-line no-console
+          console.warn('Problem when resolving conflicts:', e);
+        });
+      } else {
+        dispatch((0, _Actions2.setVisible)('incompatibility', false));
+        dispatch(setCalculationEnabled(true));
+      }
+    }
+
+    return p;
+  };
+};
+
+exports.resolveConflicts = resolveConflicts;
+
+var selectOption = function selectOption(option) {
+  var refreshOptionlist = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var showOptionDetails = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var optionclassification = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  return function (dispatch, getState) {
+    var _getState$configurato3 = getState().configurator,
+        configuration = _getState$configurato3.configuration,
+        selectedoptionclassification = _getState$configurato3.selectedoptionclassification;
+
+    if (!optionclassification) {
+      optionclassification = selectedoptionclassification;
+    }
+
+    _ServiceLocator.Services.analytics.triggerEvent(_Constant.EventTypes['switch_option'], {
+      component: optionclassification.identifier,
+      option: option.identifier
+    });
+
+    var switchOptionData = _defineProperty({}, optionclassification.identifier, _objectSpread(_objectSpread({}, option), {}, {
+      amount: isNaN(parseInt(option.amount)) ? 0 : option.amount,
+      check_results: null // it can mess the response, so should remove it.
+
+    }));
+
+    dispatch((0, _Actions2.setVisible)('optionDetails', showOptionDetails));
+    return dispatch(switchOptions(configuration, switchOptionData, false, refreshOptionlist, true));
+  };
+};
+
+exports.selectOption = selectOption;
+
+var selectMultipleOptions = function selectMultipleOptions(optionsList) {
+  return function (dispatch, getState) {
+    var configuration = (0, _Selectors.getConfiguration)((0, _Selectors.getConfigurator)(getState()));
+    var switchOptionData = {};
+
+    var _iterator4 = _createForOfIteratorHelper(optionsList),
+        _step4;
+
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var component = _step4.value;
+        switchOptionData[component.identifier] = component.selectedoptions.map(function (_ref5) {
+          var identifier = _ref5.identifier,
+              amount = _ref5.amount;
+          return {
+            identifier: identifier,
+            amount: amount || 1,
+            check_results: null
+          };
+        });
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+
+    return dispatch(switchOptions(configuration, switchOptionData, false, false, true));
+  };
+};
+
+exports.selectMultipleOptions = selectMultipleOptions;
+
+var viewOptionDetails = function viewOptionDetails(option) {
+  return function (dispatch, getState) {
+    if (!option) {
+      return;
+    }
+
+    var _getState$configurato4 = getState().configurator,
+        configuration = _getState$configurato4.configuration,
+        optiondetails = _getState$configurato4.optiondetails;
+
+    if (optiondetails.identifier !== option.identifier) {
+      dispatch(fetchOptionDetails(option.identifier, configuration));
+    } else {
+      dispatch((0, _Actions2.setVisible)('optionDetails', true));
+    }
+  };
+};
+
+exports.viewOptionDetails = viewOptionDetails;
+
+var loadConfiguration = function loadConfiguration() {
+  return /*#__PURE__*/function () {
+    var _ref6 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(dispatch, getState) {
+      var loadCode, action;
+      return regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              loadCode = getState().configurator.loadCode;
+
+              if (loadCode) {
+                _context4.next = 3;
+                break;
+              }
+
+              throw new Error((0, _i18n.t)('loadConfiguration.error.emptyCode'));
+
+            case 3:
+              dispatch((0, _Actions2.dismissError)());
+              dispatch((0, _Actions2.setWorkInProgress)('loadConfiguration', true));
+              _context4.prev = 5;
+              _context4.next = 8;
+              return dispatch(fetchConfigurationByCodeAsync(loadCode));
+
+            case 8:
+              action = _context4.sent;
+              dispatch((0, _Actions2.setVisible)('loadConfiguration', false));
+              return _context4.abrupt("return", action);
+
+            case 13:
+              _context4.prev = 13;
+              _context4.t0 = _context4["catch"](5);
+              dispatch((0, _Actions2.dismissError)()); // ignore original REQUEST_ERROR, should be handled by the caller
+
+              throw new Error((0, _i18n.t)('loadConfiguration.error.loadingFailed'));
+
+            case 17:
+              _context4.prev = 17;
+              dispatch((0, _Actions2.setWorkInProgress)('loadConfiguration', false));
+              return _context4.finish(17);
+
+            case 20:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, null, [[5, 13, 17, 20]]);
+    }));
+
+    return function (_x6, _x7) {
+      return _ref6.apply(this, arguments);
+    };
+  }();
+};
+
+exports.loadConfiguration = loadConfiguration;
+
+var receiveDesignerData = function receiveDesignerData(data) {
+  return (0, _createActionWithGlobalState.createActionWithGlobalState)({
+    type: RECEIVE_DESIGNER_DATA,
+    data: data,
+    receivedAt: Date.now()
+  });
+};
+
+exports.receiveDesignerData = receiveDesignerData;
+
+var loadDesignerData = function loadDesignerData(configuration) {
+  return /*#__PURE__*/function () {
+    var _ref7 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(dispatch) {
+      return regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              if (!(!configuration || !configuration.item || !configuration.item.identifier)) {
+                _context5.next = 2;
+                break;
+              }
+
+              return _context5.abrupt("return", dispatch((0, _Actions2.reportError)((0, _i18n.t)('loadConfigurationModes.error.missingItemIdentifier'))));
+
+            case 2:
+              dispatch((0, _Actions2.dismissError)());
+              dispatch((0, _Actions2.setWorkInProgress)('loadConfigurationModes', true));
+              _context5.prev = 4;
+              _context5.next = 7;
+              return dispatch(apiActions.postDataAsync('/configurationmodes/designer/getdata', {
+                configuration: configuration
+              }, receiveDesignerData));
+
+            case 7:
+              return _context5.abrupt("return", _context5.sent);
+
+            case 10:
+              _context5.prev = 10;
+              _context5.t0 = _context5["catch"](4);
+              return _context5.abrupt("return", dispatch((0, _Actions2.reportError)((0, _i18n.t)('loadConfigurationModes.error.loadingFailed'))));
+
+            case 13:
+              _context5.prev = 13;
+              dispatch((0, _Actions2.setWorkInProgress)('loadConfigurationModes', false));
+              return _context5.finish(13);
+
+            case 16:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, null, [[4, 10, 13, 16]]);
+    }));
+
+    return function (_x8) {
+      return _ref7.apply(this, arguments);
+    };
+  }();
+};
+
+exports.loadDesignerData = loadDesignerData;
+
+var setSelectedAmount = function setSelectedAmount(identifier, amount) {
+  var isUpdatedByUser = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return {
+    type: SET_SELECTED_AMOUNT,
+    identifier: identifier,
+    amount: amount,
+    isUpdatedByUser: isUpdatedByUser
+  };
+};
+
+exports.setSelectedAmount = setSelectedAmount;
+
+var saveBulkNames = function saveBulkNames(identifier, bulkNamesData) {
+  return {
+    type: SAVE_BULKNAMES,
+    identifier: identifier,
+    bulkNamesData: bulkNamesData
+  };
+};
+
+exports.saveBulkNames = saveBulkNames;
+
+var clearBulkNames = function clearBulkNames() {
+  return {
+    type: CLEAR_BULKNAMES
+  };
+};
+
+exports.clearBulkNames = clearBulkNames;
+
+var deleteSelectedAmount = function deleteSelectedAmount(identifier) {
+  return {
+    type: DELETE_SELECTED_AMOUNT,
+    identifier: identifier
+  };
+};
+
+exports.deleteSelectedAmount = deleteSelectedAmount;
+
+var setSelectedAmounts = function setSelectedAmounts(variant, sizes, isUpdatedByUser) {
+  return {
+    type: SET_SELECTED_AMOUNTS,
+    variant: variant,
+    sizes: sizes,
+    isUpdatedByUser: isUpdatedByUser
+  };
+};
+
+exports.setSelectedAmounts = setSelectedAmounts;
+
+var deleteSelectedAmounts = function deleteSelectedAmounts(variant, sizes) {
+  return {
+    type: DELETE_SELECTED_AMOUNTS,
+    variant: variant,
+    sizes: sizes
+  };
+};
+
+exports.deleteSelectedAmounts = deleteSelectedAmounts;
+
+var setComment = function setComment(comment) {
+  return {
+    type: SET_COMMENT,
+    comment: comment
+  };
+};
+
+exports.setComment = setComment;
+
+var switchSelectedAmount = function switchSelectedAmount(srcIdentifier, dstIdentifier) {
+  return {
+    type: SWITCH_SELECTED_AMOUNT,
+    srcIdentifier: srcIdentifier,
+    dstIdentifier: dstIdentifier
+  };
+};
+
+exports.switchSelectedAmount = switchSelectedAmount;
+
+var setSelectedCalculation = function setSelectedCalculation(identifier, value) {
+  return {
+    type: SET_SELECTED_CALCULATION,
+    identifier: identifier,
+    value: value
+  };
+};
+
+exports.setSelectedCalculation = setSelectedCalculation;