@configuratorware/configurator-frontendgui 1.28.5 → 1.29.2

package/App/Reducers/DesignData/Modifiers.js

@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyProductionMethodChangeToCanvasObjects = exports.reduceNumberOfDistinctColorsBy = exports.removeVectorizeFromOperations = exports.isOneColorAboveThreshold = exports.createVectorizeColorsMap = exports.compareOperations = exports.getEditDataFromOperations = exports.replaceColorOnOperations = exports.setColorOnOperations = void 0;
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _omit = _interopRequireDefault(require("lodash/omit"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _flatten = _interopRequireDefault(require("lodash/flatten"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _Selectors = require("./Selectors");
+
+var _Selectors2 = require("../DesignArea/Selectors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, 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 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 setColorOnOperations = function setColorOnOperations(prevOperations, color) {
+  var operations = (0, _cloneDeep["default"])(prevOperations);
+
+  for (var colorKey in operations.vectorizeColorsMap) {
+    if (!operations.vectorizeColorsMap.hasOwnProperty(colorKey)) {
+      continue;
+    }
+
+    operations.vectorizeColorsMap[colorKey] = color;
+  }
+
+  return operations;
+};
+
+exports.setColorOnOperations = setColorOnOperations;
+
+var replaceColorOnOperations = function replaceColorOnOperations(prevOperations, oldColor, color) {
+  var operations = (0, _cloneDeep["default"])(prevOperations);
+
+  for (var colorKey in operations.vectorizeColorsMap) {
+    if (!operations.vectorizeColorsMap.hasOwnProperty(colorKey)) {
+      continue;
+    }
+
+    if (operations.vectorizeColorsMap[colorKey].identifier === oldColor.identifier) {
+      operations.vectorizeColorsMap[colorKey] = color;
+    }
+  }
+
+  return operations;
+};
+
+exports.replaceColorOnOperations = replaceColorOnOperations;
+
+var getEditDataFromOperations = function getEditDataFromOperations(imageFileName, operations, designProductionMethod) {
+  var _operations$clipping = operations.clipping,
+      clipping = _operations$clipping === void 0 ? false : _operations$clipping,
+      _operations$clippingC = operations.clippingColor,
+      clippingColor = _operations$clippingC === void 0 ? false : _operations$clippingC,
+      _operations$vectorize = operations.vectorize,
+      vectorize = _operations$vectorize === void 0 ? false : _operations$vectorize,
+      _operations$vectorize2 = operations.vectorizeThreshold,
+      vectorizeThreshold = _operations$vectorize2 === void 0 ? null : _operations$vectorize2;
+  var maxColorAmount = +(0, _get["default"])(designProductionMethod, 'options.maxColorAmount', 0);
+  var vectorizeMonochrome = maxColorAmount === 1 && vectorizeThreshold === 1;
+  var result = {
+    fileName: imageFileName,
+    operations: []
+  };
+
+  if (clipping && clippingColor) {
+    result.operations.push({
+      identifier: 'clipping',
+      config: {
+        command: clipping,
+        backgroundColor: clippingColor
+      }
+    });
+  }
+
+  if (vectorize) {
+    result.operations.push({
+      identifier: 'vectorize',
+      config: {
+        threshold: vectorizeThreshold,
+        monochrome: vectorizeMonochrome
+      }
+    });
+  }
+
+  return result;
+};
+
+exports.getEditDataFromOperations = getEditDataFromOperations;
+
+var compareOperations = function compareOperations(oldOperations, newOperations) {
+  return (0, _isEqual["default"])((0, _omit["default"])(oldOperations, ['vectorizeColorsMap']), (0, _omit["default"])(newOperations, ['vectorizeColorsMap']));
+};
+
+exports.compareOperations = compareOperations;
+
+var createVectorizeColorsMap = function createVectorizeColorsMap(currentColorsMap, svgColors) {
+  // make sure the original color ordering is kept by creating placeholders for the keys
+  var vectorizeColorsMap = svgColors.reduce(function (obj, _ref) {
+    var key = _ref.key;
+    return _objectSpread(_objectSpread({}, obj), {}, _defineProperty({}, key, undefined));
+  }, {});
+  currentColorsMap && Object.keys(currentColorsMap).forEach(function (key) {
+    var oldColor = currentColorsMap[key];
+
+    if (!(0, _find["default"])(svgColors, {
+      key: key
+    })) {
+      return;
+    }
+
+    vectorizeColorsMap[key] = oldColor;
+  });
+
+  var _iterator = _createForOfIteratorHelper(svgColors),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          key = _step$value.key,
+          color = _step$value.color;
+
+      if (!vectorizeColorsMap[key]) {
+        vectorizeColorsMap[key] = color;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return vectorizeColorsMap;
+};
+
+exports.createVectorizeColorsMap = createVectorizeColorsMap;
+
+var isOneColorAboveThreshold = function isOneColorAboveThreshold(vectorizeColorsMap, vectorizeOriginalColorsMap) {
+  var threshold = 1900;
+  var aggregatedInitialColors = (0, _Selectors.getAggregatedColors)(vectorizeOriginalColorsMap || {});
+  var aggregatedCurrentColors = (0, _Selectors.getAggregatedColors)(vectorizeColorsMap || {});
+
+  if (Object.keys(aggregatedInitialColors).length !== Object.keys(aggregatedCurrentColors).length) {
+    return true;
+  }
+
+  var numberOfCustomColors = Object.values(aggregatedCurrentColors).filter(function (c) {
+    return c.identifier && JSON.parse(c.identifier).custom;
+  }).length;
+  var numberOfNotMatchingColors = Object.entries(aggregatedInitialColors).reduce(function (accumulator, _ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        initialColor = _ref3[1];
+
+    var currentColor = Object.values(aggregatedCurrentColors).find(function (c) {
+      return c.value === initialColor.value;
+    });
+
+    if (currentColor) {
+      return accumulator;
+    }
+
+    if (!aggregatedCurrentColors[key]) {
+      return accumulator + 1;
+    }
+
+    var colorDistance = (0, _Selectors2.calculateColorDistance)(initialColor.value, aggregatedCurrentColors[key].value);
+    return colorDistance === null || colorDistance > threshold ? accumulator + 1 : accumulator;
+  }, 0);
+  return numberOfNotMatchingColors > numberOfCustomColors;
+};
+
+exports.isOneColorAboveThreshold = isOneColorAboveThreshold;
+
+var removeVectorizeFromOperations = function removeVectorizeFromOperations(operations) {
+  return _objectSpread(_objectSpread({}, operations), {}, {
+    vectorize: false,
+    vectorizeThreshold: null,
+    vectorizeMaxColorAmount: undefined,
+    vectorizeColorsMap: {},
+    vectorizeOriginalColorsMap: {},
+    vectorizeMonochrome: false
+  });
+};
+
+exports.removeVectorizeFromOperations = removeVectorizeFromOperations;
+
+var getColorKeysForIdentifier = function getColorKeysForIdentifier(vectorizeColorsMap, identifier) {
+  return Object.entries(vectorizeColorsMap).filter(function (colorEntry) {
+    return colorEntry[1].identifier === identifier;
+  }).map(function (colorEntry) {
+    return colorEntry[0];
+  });
+};
+
+var findDistinctIdentifiers = function findDistinctIdentifiers(howMany, vectorizeColorsMap) {
+  var distinctIdentifiers = [];
+  Object.values(vectorizeColorsMap).forEach(function (colorEntry) {
+    if (!distinctIdentifiers.includes(colorEntry.identifier) && distinctIdentifiers.length < howMany) {
+      distinctIdentifiers.push(colorEntry.identifier);
+    }
+  });
+  return distinctIdentifiers;
+};
+
+var reduceNumberOfDistinctColorsBy = function reduceNumberOfDistinctColorsBy(vectorizeColorsMap, numberOfColorsToRemove) {
+  var numberOfUniqueColorValues = Object.values(vectorizeColorsMap).map(function (c) {
+    return c.identifier;
+  }).filter(function (c, index, array) {
+    return array.indexOf(c) === index;
+  }).length;
+
+  if (numberOfUniqueColorValues <= numberOfColorsToRemove) {
+    throw new Error('vectorizeColorsMap must have more unique colors than the number of colors we are reducing it by');
+  }
+
+  var identifiers = findDistinctIdentifiers(numberOfColorsToRemove, vectorizeColorsMap);
+  var keysForValuesToBeOverWritten = (0, _flatten["default"])(identifiers.map(function (identifier) {
+    return getColorKeysForIdentifier(vectorizeColorsMap, identifier);
+  }));
+  var sourceColorValue = Object.entries(vectorizeColorsMap).find(function (colorEntry) {
+    return !keysForValuesToBeOverWritten.includes(colorEntry[0]);
+  })[1];
+  var resultingVecotirzeColorsMap = {};
+
+  var _loop = function _loop(key) {
+    if (keysForValuesToBeOverWritten.find(function (k) {
+      return k === key;
+    })) {
+      resultingVecotirzeColorsMap[key] = sourceColorValue;
+    } else {
+      resultingVecotirzeColorsMap[key] = vectorizeColorsMap[key];
+    }
+  };
+
+  for (var key in vectorizeColorsMap) {
+    _loop(key);
+  }
+
+  return resultingVecotirzeColorsMap;
+};
+
+exports.reduceNumberOfDistinctColorsBy = reduceNumberOfDistinctColorsBy;
+
+var applyProductionMethodChangeToCanvasObjects = function applyProductionMethodChangeToCanvasObjects(newProductionMethod, oldProductionMethod, objects) {
+  return [updatePositioningAndScaling, updateLockState].reduce(function (objects, updateFunc) {
+    return updateFunc(newProductionMethod, oldProductionMethod, objects);
+  }, objects);
+};
+
+exports.applyProductionMethodChangeToCanvasObjects = applyProductionMethodChangeToCanvasObjects;
+
+var updatePositioningAndScaling = function updatePositioningAndScaling(newProductionMethod, oldProductionMethod, objects) {
+  var widthA = newProductionMethod.width,
+      heightA = newProductionMethod.height;
+  var widthB = oldProductionMethod.width,
+      heightB = oldProductionMethod.height;
+
+  if (widthA !== widthB || heightA !== heightB) {
+    var scaleX = widthA / widthB;
+    var scaleY = heightA / heightB;
+    return objects.map(function (object) {
+      var x = object.x,
+          y = object.y;
+
+      var fixedObject = _objectSpread(_objectSpread({}, object), {}, {
+        x: x * scaleX,
+        y: y * scaleY
+      });
+
+      if (fixedObject.fontSize) {
+        fixedObject.fontSize *= scaleY;
+      }
+
+      return fixedObject;
+    });
+  }
+
+  return objects;
+};
+
+var updateLockState = function updateLockState(newProductionMethod, oldProductionMethod, objects) {
+  var lockedA = newProductionMethod.designElementsLocked;
+  var lockedB = oldProductionMethod.designElementsLocked;
+
+  if (lockedA !== lockedB) {
+    return objects.map(function (object) {
+      return _objectSpread(_objectSpread({}, object), {}, {
+        rotation: 0,
+        autoFit: lockedA,
+        locked: lockedA
+      });
+    });
+  }
+
+  return objects;
+};

package/App/Reducers/DesignData/Reducer.js

@@ -0,0 +1,189 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDesignData = getDesignData;
+exports.updateConfiguratorState = updateConfiguratorState;
+exports.designDataHandler = designDataHandler;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _escape = _interopRequireDefault(require("lodash/escape"));
+
+var _unescape = _interopRequireDefault(require("lodash/unescape"));
+
+var _set = _interopRequireDefault(require("../../../Utils/Immutable/set"));
+
+var _Actions = require("./Actions");
+
+var _Selectors = require("../ImageGallery/Selectors");
+
+var _Selectors2 = require("./Selectors");
+
+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; }
+
+function getDesignData(configuratorState) {
+  return (0, _get["default"])(configuratorState, 'configuration.designdata');
+}
+
+function updateConfiguratorState(state, designAreaIdentifier, designData) {
+  var currentDesignData = getDesignData(state) || {};
+  return _objectSpread(_objectSpread({}, state), {}, {
+    configuration: _objectSpread(_objectSpread({}, state.configuration), {}, {
+      designdata: _objectSpread(_objectSpread({}, currentDesignData), {}, _defineProperty({}, designAreaIdentifier, _objectSpread(_objectSpread({}, currentDesignData[designAreaIdentifier]), designData)))
+    })
+  });
+}
+
+var regExpEscape = function regExpEscape(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+
+function shouldItemHaveBackgroundColor(item) {
+  if (item.type === 'Text') {
+    return (0, _Selectors2.hasBackgroundColor)(item.style.colors);
+  } else if (item.type === 'Image') {
+    if ((0, _get["default"])(item, 'imageData.operations.vectorize')) {
+      var objectColors = Object.values((0, _get["default"])(item, 'imageData.operations.vectorizeColorsMap') || {});
+      return (0, _Selectors2.hasBackgroundColor)(objectColors);
+    }
+  }
+
+  return false;
+}
+
+function updateItemHasBackgroundColor(state, designAreaIdentifier) {
+  var objectsPath = "configuration.designdata.".concat(designAreaIdentifier, ".canvasData.objects");
+  var objects = (0, _get["default"])(state, objectsPath, []);
+  return (0, _set["default"])(state, objectsPath, objects.map(function (object) {
+    return shouldItemHaveBackgroundColor(object) ? _objectSpread(_objectSpread({}, object), {}, {
+      hasBackgroundColor: true
+    }) : object;
+  }));
+}
+
+function designDataHandler(state, action) {
+  var designAreaIdentifier = action.designAreaIdentifier;
+
+  switch (action.type) {
+    case _Actions.actionTypes.SET_CANVAS_DATA:
+      {
+        var canvasData = action.canvasData;
+        var nextState = updateConfiguratorState(state, designAreaIdentifier, {
+          canvasData: canvasData
+        });
+        return updateItemHasBackgroundColor(nextState, designAreaIdentifier);
+      }
+
+    case _Actions.actionTypes.SET_CANVAS_DATA_MAP:
+      {
+        var canvasDataMap = action.canvasDataMap;
+        return Object.keys(canvasDataMap).reduce(function (state, designAreaIdentifier) {
+          var nextState = updateConfiguratorState(state, designAreaIdentifier, {
+            canvasData: canvasDataMap[designAreaIdentifier]
+          });
+          return updateItemHasBackgroundColor(nextState, designAreaIdentifier);
+        }, state);
+      }
+
+    case _Actions.actionTypes.SET_DESIGN_PRODUCTION_METHOD:
+      {
+        var designProductionMethodIdentifier = action.designProductionMethodIdentifier;
+        return updateConfiguratorState(state, designAreaIdentifier, {
+          designProductionMethodIdentifier: designProductionMethodIdentifier
+        });
+      }
+
+    case _Actions.actionTypes.SET_COLOR_AMOUNT:
+      {
+        var colorAmount = action.colorAmount;
+        return updateConfiguratorState(state, designAreaIdentifier, {
+          colorAmount: colorAmount
+        });
+      }
+
+    case _Actions.actionTypes.SET_INITIAL_DESIGN_DATA:
+      {
+        var initialDesignData = action.initialDesignData;
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _objectSpread(_objectSpread({}, state.configuration), {}, {
+            designdata: initialDesignData
+          })
+        });
+      }
+
+    case _Actions.actionTypes.UPDATE_IMAGE_DATA:
+      {
+        var _designAreaIdentifier = action.designAreaIdentifier,
+            imageData = action.imageData,
+            originalImageIdentifier = action.originalImageIdentifier;
+        var designdata = (0, _cloneDeep["default"])(getDesignData(state));
+        var areas = _designAreaIdentifier ? [_designAreaIdentifier] : Object.keys(designdata);
+        areas.forEach(function (area) {
+          var objects = (0, _get["default"])(designdata[area], 'canvasData.objects', []);
+          objects.forEach(function (object) {
+            if (object.imageData && (originalImageIdentifier && object.imageData.identifier === originalImageIdentifier || object.imageData.identifier === imageData.identifier)) {
+              object.imageData = (0, _cloneDeep["default"])(imageData);
+              object.src = (0, _Selectors.getPreviewUrlFromImageData)(object.imageData.preview);
+            }
+          });
+        });
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _objectSpread(_objectSpread({}, state.configuration), {}, {
+            designdata: designdata
+          })
+        });
+      }
+
+    case _Actions.actionTypes.SET_DESIGN_AREA_TEXTS_COLOR:
+      {
+        var objectsPath = "configuration.designdata.".concat(action.identifier, ".canvasData.objects");
+        var objects = (0, _get["default"])(state, objectsPath, []);
+        return (0, _set["default"])(state, objectsPath, objects.map(function (object) {
+          if (object.type !== 'Text') {
+            return object;
+          }
+
+          var content = object.content.replace(/#[0-9a-f]{3,6}/gi, action.color.value).replace(/rgb\([^)]+\)/gi, action.color.value).replace(/data-color="([^"]+)"/gi, "data-color='".concat(action.color.identifier, "'"));
+          return _objectSpread(_objectSpread({}, object), {}, {
+            content: content
+          });
+        }));
+      }
+
+    case _Actions.actionTypes.REPLACE_DESIGN_AREA_TEXTS_COLOR:
+      {
+        var _objectsPath = "configuration.designdata.".concat(action.identifier, ".canvasData.objects");
+
+        var _objects = (0, _get["default"])(state, _objectsPath, []);
+
+        return (0, _set["default"])(state, _objectsPath, _objects.map(function (object) {
+          if (object.type !== 'Text') {
+            return object;
+          }
+
+          var colorToReplace = Object.values(action.oldValue).map(regExpEscape).join('|');
+          var content = object.content.replace(/data-color="(.*?)"/gi, function (originalAttr, dataAttr) {
+            return (0, _unescape["default"])(dataAttr) === action.oldColorData ? "data-color=\"".concat((0, _escape["default"])(action.colorData), "\"") : originalAttr;
+          }).replace(new RegExp("<([^<]*)color: (".concat(colorToReplace, ");([^>]*)>"), 'gi'), "<$1color: ".concat(action.value, ";$3>"));
+          return _objectSpread(_objectSpread({}, object), {}, {
+            content: content
+          });
+        }));
+      }
+
+    default:
+      {
+        return state;
+      }
+  }
+}

package/App/Reducers/DesignData/Selectors.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPlaceholderObject = exports.getColorKeysForAggregatedColor = exports.getOriginalColorsMap = exports.getInitialMaxColorAmount = exports.getAggregatedColorCount = exports.getAggregatedColors = exports.hasBackgroundColor = void 0;
+
+var _Selectors = require("../DesignArea/Selectors");
+
+var _styles = require("@material-ui/core/styles");
+
+var _DesignDataService = require("../../Services/DesignDataService");
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _size = _interopRequireDefault(require("lodash/size"));
+
+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 hasBackgroundColor = function hasBackgroundColor(colors) {
+  return colors.map(function (color) {
+    return (0, _Selectors.isValidHex)(color.value) ? (0, _styles.hexToRgb)(color.value) : color.value || 'rgb(0, 0, 0)';
+  }).map(_DesignDataService.getRgbValuesFromString).some(_DesignDataService.isColorTooBright);
+};
+
+exports.hasBackgroundColor = hasBackgroundColor;
+
+var getAggregatedColors = function getAggregatedColors(colors) {
+  return Object.keys(colors).reduce(function (uniqColors, colorKey) {
+    var color = colors[colorKey];
+
+    if ((0, _find["default"])(uniqColors, function (c) {
+      return c.identifier === color.identifier;
+    })) {
+      return uniqColors;
+    }
+
+    return _objectSpread(_objectSpread({}, uniqColors), {}, _defineProperty({}, colorKey, color));
+  }, {});
+};
+
+exports.getAggregatedColors = getAggregatedColors;
+
+var getAggregatedColorCount = function getAggregatedColorCount(colors) {
+  return (0, _size["default"])(getAggregatedColors(colors));
+};
+
+exports.getAggregatedColorCount = getAggregatedColorCount;
+
+var getInitialMaxColorAmount = function getInitialMaxColorAmount(state) {
+  return (0, _get["default"])(state, 'imageGallery.selectedImage.operations.vectorizeMaxColorAmount', undefined);
+};
+
+exports.getInitialMaxColorAmount = getInitialMaxColorAmount;
+
+var getOriginalColorsMap = function getOriginalColorsMap(state) {
+  return (0, _get["default"])(state, 'imageGallery.selectedImage.operations.vectorizeOriginalColorsMap', {});
+};
+
+exports.getOriginalColorsMap = getOriginalColorsMap;
+
+var getColorKeysForAggregatedColor = function getColorKeysForAggregatedColor(vectorizeColorsMap, colorKey) {
+  var colors = []; //loop over the elements and detect all colors with the same mapped value
+
+  var colorToColorize = vectorizeColorsMap[colorKey];
+
+  for (var _colorKey in vectorizeColorsMap) {
+    if (!vectorizeColorsMap.hasOwnProperty(_colorKey)) {
+      continue;
+    }
+
+    if (vectorizeColorsMap[_colorKey].identifier === colorToColorize.identifier) {
+      colors.push(_colorKey);
+    }
+  }
+
+  return colors;
+};
+
+exports.getColorKeysForAggregatedColor = getColorKeysForAggregatedColor;
+
+var isPlaceholderObject = function isPlaceholderObject(obj) {
+  return obj.type === 'Text' && (0, _Selectors.isPlaceholderContent)(obj.content) || obj.type === 'Image' && obj.imageData.isPlaceHolderImage;
+};
+
+exports.isPlaceholderObject = isPlaceholderObject;

package/App/Reducers/DesignData/Transformers.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initDefaultColor = void 0;
+
+/**
+ * Sets a default color to the svg if it does not contain any
+ * @param {string} svgStr
+ * @return {string}
+ */
+var initDefaultColor = function initDefaultColor(svgStr) {
+  if (!/#[0-9a-f]{3,6}/i.test(svgStr)) {
+    var styleFix = 'fill: #000000;';
+    return svgStr.replace(/<svg((?!style)[^>])*(style="([^"]+)")?[^>]*>/, function insertDefaultColor() {
+      // appends it to the current style if exists, otherwise in a style attribute
+      var svgTag = arguments[0];
+      var currentStyle = arguments[3];
+      return currentStyle ? svgTag.replace(currentStyle, currentStyle + ' ' + styleFix) : svgTag.replace('>', " style=\"".concat(styleFix, "\">"));
+    });
+  }
+
+  return svgStr;
+};
+
+exports.initDefaultColor = initDefaultColor;

package/App/Reducers/DesignView/Actions.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectDesignView = exports.actionTypes = void 0;
+var actionTypes = {
+  SELECT_DESIGN_VIEW: 'DesignView/SELECT_DESIGN_VIEW'
+};
+exports.actionTypes = actionTypes;
+
+var selectDesignView = function selectDesignView(designViewIdentifier) {
+  return {
+    type: actionTypes.SELECT_DESIGN_VIEW,
+    designViewIdentifier: designViewIdentifier
+  };
+};
+
+exports.selectDesignView = selectDesignView;