@configuratorware/configurator-frontendgui 1.28.1 → 1.29.0

package/App/Reducers/DesignArea/Transformers.js

@@ -0,0 +1,333 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processConfigurationModes = processConfigurationModes;
+exports.recalculateSingleDesignArea = recalculateSingleDesignArea;
+exports.recalculateDesignAreas = recalculateDesignAreas;
+exports.createInitialDesignDataFromDesignAreas = createInitialDesignDataFromDesignAreas;
+
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _first = _interopRequireDefault(require("lodash/first"));
+
+var _lowerCase = _interopRequireDefault(require("lodash/lowerCase"));
+
+var _isPositiveNumber = require("../../../Utils/Math/isPositiveNumber");
+
+var _Selectors = require("./Selectors");
+
+var _Selectors2 = require("../Configurator/Selectors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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; }
+
+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; }
+
+/**
+ * Creates the state from the JSON object returned by the server.
+ *
+ * Loops through the design views and builds a merged list from the design areas (that will contains only
+ * one instance from all the available areas across the design views). It sets the designView origin for
+ * every design area object, so later it can be identified.
+ *
+ * @param configurationModes
+ * @returns {{filteredDesignAreas: Object[], selectedDesignArea: {}}}
+ */
+function processConfigurationModes(configurationModes) {
+  if (!(0, _isObject["default"])(configurationModes) || !(0, _isArray["default"])(configurationModes.designViews)) {
+    // eslint-disable-next-line no-console
+    console.warn('Invalid argument: configurationModes!', configurationModes);
+    return {};
+  }
+
+  var designViews = configurationModes.designViews,
+      uploadMaxSize = configurationModes.uploadMaxSize,
+      maxZoom2d = configurationModes.maxZoom2d;
+  var filteredDesignAreas = [];
+  var designAreaMap = {};
+
+  var _iterator = _createForOfIteratorHelper(designViews),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var designView = _step.value;
+      var designAreas = (0, _get["default"])(designView, 'designAreas') || [];
+
+      var _iterator2 = _createForOfIteratorHelper(designAreas),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var designArea = _step2.value;
+          var identifier = designArea.identifier;
+
+          if (identifier && !designAreaMap[identifier]) {
+            // for the first occurrence of the design area, just add it to the list and the area map
+            var da = _objectSpread(_objectSpread({}, designArea), {}, {
+              designView: designView
+            });
+
+            designAreaMap[identifier] = da;
+            filteredDesignAreas.push(da);
+          } else {
+            // try to guess the main view for the design area
+            var defaultViewIdentifier = (0, _get["default"])(designArea, 'defaultViewIdentifier'); // 2D
+
+            var selectedCameraView = (0, _get["default"])(designArea, 'customData.selectedCameraView'); // 3D
+
+            var viewIdentifier = defaultViewIdentifier || selectedCameraView;
+
+            if (viewIdentifier && viewIdentifier === designView.identifier || !viewIdentifier && designAreas.length === 1 // it's the only area of the view
+            ) {
+              Object.assign(designAreaMap[identifier], designArea, {
+                designView: designView
+              });
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  sortDesignAreas(filteredDesignAreas);
+  return {
+    filteredDesignAreas: filteredDesignAreas,
+    selectedDesignArea: {},
+    uploadMaxSize: uploadMaxSize,
+    initialCanvasPosition: filteredDesignAreas,
+    maxZoom2d: maxZoom2d
+  };
+}
+
+var sortAlphabetically = function sortAlphabetically(a, b) {
+  return (0, _lowerCase["default"])(a.title) !== (0, _lowerCase["default"])(b.title) ? (0, _lowerCase["default"])(a.title) < (0, _lowerCase["default"])(b.title) ? -1 : 1 : 0;
+};
+
+var sortDesignAreas = function sortDesignAreas(designAreas) {
+  return designAreas.sort(function (a, b) {
+    if (a.sequenceNumber !== b.sequenceNumber) {
+      return parseInt(a.sequenceNumber) < parseInt(b.sequenceNumber) ? -1 : 1;
+    } else {
+      return sortAlphabetically(a, b);
+    }
+  });
+};
+
+var createDesignAreaPatch = function createDesignAreaPatch(designArea, sizeRatio, visualMode) {
+  var widthRatio = sizeRatio.widthRatio,
+      heightRatio = sizeRatio.heightRatio,
+      aspectRatio = sizeRatio.aspectRatio;
+
+  var position = _objectSpread({}, designArea.position);
+
+  var baseShape = _objectSpread({}, designArea.baseShape);
+
+  position.width = Math.round(designArea.position.width * widthRatio);
+  position.height = Math.round(position.width / aspectRatio); // skip update if width or height is not valid
+
+  if (!((0, _isPositiveNumber.isPositiveNumber)(position.width) && (0, _isPositiveNumber.isPositiveNumber)(position.height))) {
+    return false;
+  }
+
+  if (visualMode.is2D()) {
+    // adjust the base shape size to fit the selected design area
+    var _position$angle = position.angle,
+        angle = _position$angle === void 0 ? 0 : _position$angle;
+    var sinAbs = Math.abs(Math.sin(angle));
+    var cosAbs = Math.abs(Math.cos(angle));
+    var bbWidthRatio = sinAbs * heightRatio + cosAbs * widthRatio;
+    var bbHeightRatio = cosAbs * heightRatio + sinAbs * widthRatio;
+    baseShape.width = Math.round(designArea.baseShape.width * bbWidthRatio);
+    baseShape.height = Math.round(designArea.baseShape.height * bbHeightRatio);
+    position.x = position.x * bbWidthRatio;
+    position.y = position.y * bbHeightRatio;
+  }
+
+  return {
+    position: position,
+    baseShape: baseShape
+  };
+};
+
+function recalculateSingleDesignArea(state, designArea) {
+  var visualMode = (0, _Selectors2.visualizationModeCheck)(state);
+  var designProductionMethods = designArea.designProductionMethods;
+  var sizeObject = designArea.width && designArea.height ? designArea : (0, _first["default"])(designProductionMethods) || {};
+  var dpm = (0, _Selectors.getSelectedDesignProductionMethodForDesignArea)(state, designArea);
+  var widthRatio = dpm.width / sizeObject.width;
+  var heightRatio = dpm.height / sizeObject.height;
+  var aspectRatio = dpm.width / dpm.height;
+  var sizeRatio = {
+    widthRatio: widthRatio,
+    heightRatio: heightRatio,
+    aspectRatio: aspectRatio
+  };
+  var patch = createDesignAreaPatch(designArea, sizeRatio, visualMode);
+  return _objectSpread(_objectSpread({}, designArea), patch);
+}
+
+function recalculateDesignAreas(designAreaState, designProductionMethodMap, visualMode) {
+  var designAreas = designAreaState.selectedDesignArea.identifier ? [designAreaState.selectedDesignArea] : designAreaState.filteredDesignAreas;
+
+  var filteredDesignAreas = _toConsumableArray(designAreaState.filteredDesignAreas);
+
+  var selectedDesignArea = designAreaState.selectedDesignArea;
+
+  var _iterator3 = _createForOfIteratorHelper(designAreas),
+      _step3;
+
+  try {
+    var _loop = function _loop() {
+      var _designArea = _step3.value;
+
+      var designArea = _objectSpread({}, _designArea);
+
+      var designProductionMethods = designArea.designProductionMethods;
+      var sizeObject = designArea.width && designArea.height ? designArea : (0, _first["default"])(designProductionMethods) || {};
+      var dpm = designProductionMethodMap[designArea.identifier];
+      var widthRatio = dpm.width / sizeObject.width;
+      var heightRatio = dpm.height / sizeObject.height;
+      var aspectRatio = dpm.width / dpm.height;
+      var sizeRatio = {
+        widthRatio: widthRatio,
+        heightRatio: heightRatio,
+        aspectRatio: aspectRatio
+      };
+      var original = (0, _find["default"])(designAreaState.initialCanvasPosition, {
+        identifier: designArea.identifier
+      });
+      var patch = createDesignAreaPatch(original, sizeRatio, visualMode);
+
+      if (!patch) {
+        return "continue";
+      }
+
+      var designView = _objectSpread(_objectSpread({}, designArea.designView), {}, {
+        designAreas: designArea.designView.designAreas.map(function (da) {
+          return da !== designArea && da.identifier === designArea.identifier ? _objectSpread(_objectSpread({}, da), patch) : da;
+        })
+      });
+
+      Object.assign(designArea, _objectSpread(_objectSpread({}, patch), {}, {
+        designView: designView
+      }));
+      var index = filteredDesignAreas.indexOf(_designArea);
+
+      if (index !== -1) {
+        filteredDesignAreas[index] = designArea;
+      }
+
+      if (selectedDesignArea && selectedDesignArea.identifier === designArea.identifier) {
+        selectedDesignArea = designArea;
+      }
+    };
+
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _ret = _loop();
+
+      if (_ret === "continue") continue;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  return _objectSpread(_objectSpread({}, designAreaState), {}, {
+    selectedDesignArea: selectedDesignArea,
+    filteredDesignAreas: filteredDesignAreas
+  });
+}
+
+function createInitialDesignDataFromDesignAreas(designAreas) {
+  var designData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var initialDesignData = {};
+
+  var _iterator4 = _createForOfIteratorHelper(designAreas),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var area = _step4.value;
+      var data = (0, _isObject["default"])(designData) ? _objectSpread({}, designData[area.identifier]) : {};
+      var preSelection = (0, _Selectors.getDesignAreaPreSelection)(area.identifier);
+      var method = void 0;
+
+      if (preSelection.productionMethod) {
+        var preSelectionMethod = (0, _find["default"])(area.designProductionMethods, {
+          identifier: preSelection.productionMethod
+        });
+
+        if (preSelectionMethod) {
+          method = preSelectionMethod;
+        }
+      }
+
+      if (!method) {
+        method = (0, _find["default"])(area.designProductionMethods, {
+          isDefault: true
+        }) || (0, _first["default"])(area.designProductionMethods);
+      }
+
+      if (!data.canvasData) {
+        data.canvasData = null;
+      }
+
+      if (!data.designProductionMethodIdentifier || !data.canvasData || !(0, _find["default"])(area.designProductionMethods, {
+        identifier: data.designProductionMethodIdentifier
+      })) {
+        data.designProductionMethodIdentifier = method ? method.identifier : 'print';
+        data.canvasData = null;
+      }
+
+      var preselectedColorAmount = data.colorAmount ? data.colorAmount : preSelection.colorAmount;
+      var colorAmount = (0, _Selectors.getDesignAreaColorAmount)(+(0, _get["default"])(method, 'options.maxColorAmount', 0), +preselectedColorAmount);
+
+      if (colorAmount !== null) {
+        data.colorAmount = colorAmount;
+      }
+
+      initialDesignData[area.identifier] = data;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  return initialDesignData;
+}

package/App/Reducers/DesignData/Actions.js

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateLinkedImagesWithImageData = exports.replaceDesignAreaTextsColor = exports.setDesignAreaTextsColor = exports.showProductionMethodChangeConfirm = exports.showProductionMethodChangeColorsConfirm = exports.showProductionMethodRemoveImagesConfirm = exports.showMinFontSizeConfirm = exports.showMaxColorChangeConfirm = exports.showColorUsageConfirm = exports.showSwitchToProductionMethodWithoutVectorization = exports.showSwitchToProductionMethodWithVectorization = exports.setInitialDesignData = exports.setColorAmount = exports.updateImageData = exports.setDesignProductionMethod = exports.setCanvasData = exports.createDesignDataAction = exports.actionTypes = void 0;
+
+var _i18n = require("../../../Framework/i18n");
+
+var _Actions = require("../Confirm/Actions");
+
+var _Actions2 = require("../DesignArea/Actions");
+
+var _Selectors = require("../DesignArea/Selectors");
+
+var _Reducer = require("./Reducer");
+
+var _Selectors2 = require("../Configurator/Selectors");
+
+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 actionTypes = {
+  SET_CANVAS_DATA: 'DesignData/SET_CANVAS_DATA',
+  SET_DESIGN_PRODUCTION_METHOD: 'DesignData/SET_DESIGN_PRODUCTION_METHOD',
+  SET_COLOR_AMOUNT: 'DesignData/SET_COLOR_AMOUNT',
+  SET_INITIAL_DESIGN_DATA: 'DesignData/SET_INITIAL_DESIGN_DATA',
+  UPDATE_IMAGE_DATA: 'DesignData/UPDATE_IMAGE_DATA',
+  SET_DESIGN_AREA_TEXTS_COLOR: 'DesignData/SET_DESIGN_AREA_TEXTS_COLOR',
+  REPLACE_DESIGN_AREA_TEXTS_COLOR: 'DesignData/REPLACE_DESIGN_AREA_TEXTS_COLOR',
+  SET_CANVAS_DATA_MAP: 'DesignData/SET_CANVAS_DATA_MAP'
+};
+exports.actionTypes = actionTypes;
+
+var createDesignDataAction = function createDesignDataAction(actionObject) {
+  return function (dispatch, getState) {
+    var _getState = getState(),
+        designAreaIdentifier = _getState.designArea.selectedDesignArea.identifier; // skip if no designAreaIdentifier
+
+
+    if (designAreaIdentifier) {
+      return dispatch(_objectSpread(_objectSpread({}, actionObject), {}, {
+        designAreaIdentifier: designAreaIdentifier
+      }));
+    }
+  };
+};
+
+exports.createDesignDataAction = createDesignDataAction;
+
+var setCanvasData = function setCanvasData(canvasData, targetDesignAreaIdentifier) {
+  return function (dispatch, getState) {
+    var _getState2 = getState(),
+        selectedDesignArea = _getState2.designArea.selectedDesignArea;
+
+    var designAreaIdentifier = targetDesignAreaIdentifier || selectedDesignArea.identifier; // skip if no designAreaIdentifier
+
+    if (designAreaIdentifier) {
+      dispatch((0, _Actions2.setPreviousEditedDesignAreaIdentier)(designAreaIdentifier));
+      return dispatch({
+        type: actionTypes.SET_CANVAS_DATA,
+        canvasData: canvasData,
+        designAreaIdentifier: designAreaIdentifier
+      });
+    }
+  };
+};
+
+exports.setCanvasData = setCanvasData;
+
+var setDesignProductionMethod = function setDesignProductionMethod(designProductionMethodIdentifier) {
+  return createDesignDataAction({
+    type: actionTypes.SET_DESIGN_PRODUCTION_METHOD,
+    designProductionMethodIdentifier: designProductionMethodIdentifier
+  });
+};
+
+exports.setDesignProductionMethod = setDesignProductionMethod;
+
+var updateImageData = function updateImageData(imageData) {
+  var originalImageIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return function (dispatch, getState) {
+    var designAreaIdentifier = (0, _Selectors.getSelectedDesignArea)(getState()).identifier;
+    return dispatch({
+      type: actionTypes.UPDATE_IMAGE_DATA,
+      imageData: imageData,
+      designAreaIdentifier: designAreaIdentifier,
+      originalImageIdentifier: originalImageIdentifier
+    });
+  };
+};
+
+exports.updateImageData = updateImageData;
+
+var setColorAmount = function setColorAmount(colorAmount) {
+  return createDesignDataAction({
+    type: actionTypes.SET_COLOR_AMOUNT,
+    colorAmount: colorAmount
+  });
+};
+
+exports.setColorAmount = setColorAmount;
+
+var setInitialDesignData = function setInitialDesignData(initialDesignData) {
+  return {
+    type: actionTypes.SET_INITIAL_DESIGN_DATA,
+    initialDesignData: initialDesignData
+  };
+};
+
+exports.setInitialDesignData = setInitialDesignData;
+
+var showSwitchToProductionMethodWithVectorization = function showSwitchToProductionMethodWithVectorization() {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('designProductionMethodSwitch.toVectorization.message'), (0, _i18n.t)('designProductionMethodSwitch.toVectorization.ok'), (0, _i18n.t)('designProductionMethodSwitch.toVectorization.cancel'));
+};
+
+exports.showSwitchToProductionMethodWithVectorization = showSwitchToProductionMethodWithVectorization;
+
+var showSwitchToProductionMethodWithoutVectorization = function showSwitchToProductionMethodWithoutVectorization() {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('designProductionMethodSwitch.fromVectorization.message'), (0, _i18n.t)('designProductionMethodSwitch.fromVectorization.ok'), (0, _i18n.t)('designProductionMethodSwitch.fromVectorization.cancel'));
+};
+
+exports.showSwitchToProductionMethodWithoutVectorization = showSwitchToProductionMethodWithoutVectorization;
+
+var showColorUsageConfirm = function showColorUsageConfirm(colorCount, maxColorCount) {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('colorAmountAlert.colorChange', {
+    colorAmount: colorCount,
+    maxColorAmount: maxColorCount
+  }), (0, _i18n.t)('colorAmountAlert.colorChangeOk', {
+    colorAmount: colorCount
+  }), (0, _i18n.t)('colorAmountAlert.colorChangeCancel', {
+    colorAmount: maxColorCount
+  }));
+};
+
+exports.showColorUsageConfirm = showColorUsageConfirm;
+
+var showMaxColorChangeConfirm = function showMaxColorChangeConfirm(colorCount, maxColorCount, currentColorCount) {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('colorAmountAlert.maxColorChange', {
+    colorAmount: colorCount,
+    maxColorAmount: maxColorCount
+  }), (0, _i18n.t)('colorAmountAlert.maxColorChangeOk', {
+    colorAmount: maxColorCount
+  }), (0, _i18n.t)('colorAmountAlert.maxColorChangeCancel', {
+    colorAmount: currentColorCount
+  }));
+};
+
+exports.showMaxColorChangeConfirm = showMaxColorChangeConfirm;
+
+var showMinFontSizeConfirm = function showMinFontSizeConfirm(fontSizeMin) {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('minFontSizeWarning.message', {
+    fontSizeMin: fontSizeMin
+  }), (0, _i18n.t)('minFontSizeWarning.okButtonLabel'), (0, _i18n.t)('minFontSizeWarning.cancelButtonLabel'));
+};
+
+exports.showMinFontSizeConfirm = showMinFontSizeConfirm;
+
+var showProductionMethodRemoveImagesConfirm = function showProductionMethodRemoveImagesConfirm() {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('colorAmountAlert.productionMethodRemoveImagesWarning.message'), (0, _i18n.t)('colorAmountAlert.productionMethodRemoveImagesWarning.okButtonLabel'), (0, _i18n.t)('colorAmountAlert.productionMethodRemoveImagesWarning.cancelButtonLabel'));
+};
+
+exports.showProductionMethodRemoveImagesConfirm = showProductionMethodRemoveImagesConfirm;
+
+var showProductionMethodChangeColorsConfirm = function showProductionMethodChangeColorsConfirm() {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('colorAmountAlert.productionMethodChangeColorsWarning.message'), (0, _i18n.t)('colorAmountAlert.productionMethodChangeColorsWarning.okButtonLabel'), (0, _i18n.t)('colorAmountAlert.productionMethodChangeColorsWarning.cancelButtonLabel'));
+};
+
+exports.showProductionMethodChangeColorsConfirm = showProductionMethodChangeColorsConfirm;
+
+var showProductionMethodChangeConfirm = function showProductionMethodChangeConfirm() {
+  return (0, _Actions.showConfirm)((0, _i18n.t)('designProductionChangeAlert.message'), (0, _i18n.t)('designProductionChangeAlert.okButtonLabel'), (0, _i18n.t)('designProductionChangeAlert.cancelButtonLabel'));
+};
+
+exports.showProductionMethodChangeConfirm = showProductionMethodChangeConfirm;
+
+var setDesignAreaTextsColor = function setDesignAreaTextsColor(identifier, color) {
+  return {
+    type: actionTypes.SET_DESIGN_AREA_TEXTS_COLOR,
+    identifier: identifier,
+    color: color
+  };
+};
+
+exports.setDesignAreaTextsColor = setDesignAreaTextsColor;
+
+var replaceDesignAreaTextsColor = function replaceDesignAreaTextsColor(identifier, oldColorData, oldValue, colorData, value) {
+  return {
+    type: actionTypes.REPLACE_DESIGN_AREA_TEXTS_COLOR,
+    identifier: identifier,
+    oldColorData: oldColorData,
+    oldValue: oldValue,
+    colorData: colorData,
+    value: value
+  };
+};
+
+exports.replaceDesignAreaTextsColor = replaceDesignAreaTextsColor;
+
+var updateLinkedImagesWithImageData = function updateLinkedImagesWithImageData(imageIdentifier, imageData) {
+  return function (dispatch, getState) {
+    var designData = (0, _Reducer.getDesignData)((0, _Selectors2.getConfigurator)(getState()));
+    var canvasDataMap = {};
+    Object.keys(designData).filter(function (designAreaIdentifier) {
+      var canvasData = designData[designAreaIdentifier].canvasData;
+      return canvasData && canvasData.objects && canvasData.objects.length > 0;
+    }).forEach(function (designAreaIdentifier) {
+      var canvasData = designData[designAreaIdentifier].canvasData;
+      var objects = canvasData.objects;
+      canvasDataMap[designAreaIdentifier] = _objectSpread(_objectSpread({}, canvasData), {}, {
+        objects: objects && objects.map(function (object) {
+          if (object.type === 'Image' && object.imageData.identifier === imageIdentifier) {
+            return _objectSpread(_objectSpread({}, object), {}, {
+              imageData: imageData
+            });
+          }
+
+          return object;
+        })
+      });
+    });
+    dispatch({
+      type: actionTypes.SET_CANVAS_DATA_MAP,
+      canvasDataMap: canvasDataMap
+    });
+  };
+};
+
+exports.updateLinkedImagesWithImageData = updateLinkedImagesWithImageData;