@configuratorware/configurator-frontendgui 1.28.3 → 1.29.1

package/App/Reducers/DesignView/Reducer.js

@@ -0,0 +1,165 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = designViewReducer;
+
+var _Actions = require("./Actions");
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var configuratorActionTypes = _interopRequireWildcard(require("../Configurator/Actions"));
+
+var _Transformers = require("./Transformers");
+
+var _Selectors = require("../ConfigurationMode/Selectors");
+
+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 _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 _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 _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 _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 _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; }
+
+var orderDesignAreasBySize = function orderDesignAreasBySize(designAreas) {
+  return designAreas && _toConsumableArray(designAreas).sort(_Transformers.compareDesignAreasBySize);
+};
+
+var prepareDesignViews = function prepareDesignViews(designViews) {
+  return designViews.map(function (designView) {
+    return _objectSpread(_objectSpread({}, designView), {}, {
+      designAreas: orderDesignAreasBySize(designView.designAreas)
+    });
+  });
+};
+
+var initialState = {
+  designViews: [],
+  selectedDesignView: {},
+  autogeneratedDesignViews: [],
+  viewThumbnailImages: []
+};
+
+function designViewReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  switch (action.type) {
+    case _Actions.actionTypes.SELECT_DESIGN_VIEW:
+      {
+        var designViewIdentifier = action.designViewIdentifier;
+        var designView = (0, _find["default"])(state.designViews, {
+          identifier: designViewIdentifier
+        });
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedDesignView: designView
+        });
+      }
+
+    case configuratorActionTypes.RECEIVE_DESIGNER_DATA:
+      {
+        var autogeneratedDesignViews = state.autogeneratedDesignViews;
+        var designViews = action.data.designViews;
+
+        if (!designViews || !designViews.length) {
+          // if there are no design views defined, use the autogenerated ones as fallback
+          // use-case: missing visual maintenance setup for layer type visualization (designer only)
+          if (autogeneratedDesignViews.length) {
+            return _objectSpread(_objectSpread({}, state), {}, {
+              designViews: autogeneratedDesignViews
+            });
+          }
+
+          return state;
+        }
+
+        if (autogeneratedDesignViews.length) {
+          // if the design views are already defined by the viewImages they need to be merged
+          var updatedDesignViews = autogeneratedDesignViews.map(function (designView) {
+            return _objectSpread(_objectSpread({}, designViews.find(function (_ref) {
+              var identifier = _ref.identifier;
+              return designView.identifier === identifier;
+            })), designView);
+          });
+          return _objectSpread(_objectSpread({}, state), {}, {
+            designViews: prepareDesignViews(updatedDesignViews),
+            selectedDesignView: {}
+          });
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          designViews: prepareDesignViews(designViews),
+          selectedDesignView: {}
+        });
+      }
+
+    case configuratorActionTypes.RECEIVE_CONFIGURATION:
+      {
+        var viewImages = (0, _get["default"])(action, 'data.visualizationData.viewImages');
+        var viewIdentifiers = viewImages && Object.keys(viewImages);
+
+        if (viewIdentifiers && viewIdentifiers.length) {
+          var viewThumbnailImages = (0, _get["default"])(action, 'data.visualizationData.viewThumbImages');
+
+          var _autogeneratedDesignViews = viewIdentifiers.map(function (identifier) {
+            return {
+              identifier: identifier
+            };
+          }); // if designer mode is enabled, the design views are loaded in a separate action
+          // so it's not stored directly as designViews
+
+
+          if ((0, _Selectors.getConfigurationModes)((0, _get["default"])(action, 'data.item')).designer) {
+            return _objectSpread(_objectSpread({}, state), {}, {
+              designViews: [],
+              selectedDesignView: {},
+              autogeneratedDesignViews: _autogeneratedDesignViews,
+              viewThumbnailImages: viewThumbnailImages
+            });
+          } // otherwise designViews are not expected from other actions
+          // so the autogenerated ones should be used as fallback
+
+
+          var selectedDesignView = _autogeneratedDesignViews[0];
+          return _objectSpread(_objectSpread({}, state), {}, {
+            designViews: _autogeneratedDesignViews,
+            selectedDesignView: selectedDesignView,
+            autogeneratedDesignViews: _autogeneratedDesignViews,
+            viewThumbnailImages: viewThumbnailImages
+          });
+        } // receiving a new configuration should always reset the design view state to not mix them up
+
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          designViews: [],
+          selectedDesignView: {},
+          autogeneratedDesignViews: [],
+          viewThumbnailImages: []
+        });
+      }
+  }
+
+  return state;
+}

package/App/Reducers/DesignView/Selectors.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCurrentDesignView = exports.getSelectedDesignViewIdentifier = exports.getDesignViewLength = exports.get2DModelSrc = exports.getThumbnailData = void 0;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _Selectors = require("../Configurator/Selectors");
+
+var _Selectors2 = require("../DesignArea/Selectors");
+
+var _Transformers = require("./Transformers");
+
+var _Transformers2 = require("../DesignArea/Transformers");
+
+var _Selectors3 = require("../ConfigurationMode/Selectors");
+
+var _getImageUrl = _interopRequireDefault(require("../../Utils/getImageUrl"));
+
+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 _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 _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 _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 getThumbnailData = function getThumbnailData(state) {
+  var items = state.designView.designViews.map(function (designView) {
+    var thumbnailImage = state.designView.viewThumbnailImages[designView.identifier];
+    return _objectSpread({
+      identifier: designView.identifier
+    }, thumbnailImage && {
+      thumbnailImage: (0, _getImageUrl["default"])(thumbnailImage)
+    });
+  });
+  var dotMode = !items.every(function (item) {
+    return item.thumbnailImage;
+  });
+  var currentConfiguration = (0, _Selectors3.getSelectedConfigurationMode)(state); // on designer, we fall back to the older thumbnail images, if they exist
+
+  if (currentConfiguration === 'designer' && dotMode === true) {
+    var configuratorState = (0, _Selectors.getConfigurator)(state);
+    var itemIdentifier = (0, _Selectors.getSelectedVariantIdentifier)(configuratorState) || (0, _Selectors.getItem)(configuratorState).identifier;
+    var designFallBackItems = state.designView.designViews.map(function (designView) {
+      var thumbnailImage = (0, _get["default"])(designView.thumbnails, itemIdentifier);
+      return _objectSpread({
+        identifier: designView.identifier
+      }, thumbnailImage && {
+        thumbnailImage: (0, _getImageUrl["default"])(thumbnailImage)
+      });
+    });
+    return {
+      items: designFallBackItems,
+      dotMode: !designFallBackItems.every(function (item) {
+        return item.thumbnailImage;
+      })
+    };
+  }
+
+  return {
+    dotMode: dotMode,
+    items: items
+  };
+};
+
+exports.getThumbnailData = getThumbnailData;
+
+var get2DModelSrc = function get2DModelSrc(state, host) {
+  var configuratorState = (0, _Selectors.getConfigurator)(state);
+  var itemIdentifier = (0, _Selectors.getSelectedVariantIdentifier)(configuratorState) || (0, _Selectors.getItem)(configuratorState).identifier;
+  var designArea = (0, _Selectors2.getSelectedDesignArea)(state);
+  var designView = designArea && designArea.designView || state.designView.selectedDesignView;
+  var src = (0, _get["default"])(designView, "images.".concat(itemIdentifier), null);
+  return src ? "".concat(host).concat(src) : null;
+};
+
+exports.get2DModelSrc = get2DModelSrc;
+
+var getDesignViewLength = function getDesignViewLength(state) {
+  return (0, _get["default"])(state.designView.designViews, 'length', 0);
+};
+
+exports.getDesignViewLength = getDesignViewLength;
+
+var getSelectedDesignViewIdentifier = function getSelectedDesignViewIdentifier(state) {
+  return state.designView.selectedDesignView.identifier;
+};
+/**
+ * Returns the selected design view with the current design area data, or false if not selected
+ * @param {{designView: {}, designArea: {}}} state
+ * @return {*|{designAreas: *}|boolean}
+ */
+
+
+exports.getSelectedDesignViewIdentifier = getSelectedDesignViewIdentifier;
+
+var getCurrentDesignView = function getCurrentDesignView(state) {
+  var selectedDesignView = state.designView.selectedDesignView;
+
+  if (!selectedDesignView || !selectedDesignView.identifier) {
+    return false;
+  }
+
+  if (!selectedDesignView.designAreas) {
+    return selectedDesignView;
+  }
+
+  return _objectSpread(_objectSpread({}, selectedDesignView), {}, {
+    designAreas: _toConsumableArray(selectedDesignView.designAreas.map(function (designArea) {
+      return (0, _Transformers2.recalculateSingleDesignArea)(state, designArea);
+    })).sort(_Transformers.compareDesignAreasBySize)
+  });
+};
+
+exports.getCurrentDesignView = getCurrentDesignView;

package/App/Reducers/DesignView/Transformers.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareDesignAreasBySize = compareDesignAreasBySize;
+
+/**
+ * Compares design areas by size.
+ *
+ * @param {Object} firstDesignArea
+ * @param {Object} firstDesignArea.baseShape
+ * @param {number} firstDesignArea.baseShape.width
+ * @param {number} firstDesignArea.baseShape.height
+ * @param {Object} secondDesignArea
+ * @param {Object} secondDesignArea.baseShape
+ * @param {number} secondDesignArea.baseShape.width
+ * @param {number} secondDesignArea.baseShape.height
+ * @returns {number}
+ */
+function compareDesignAreasBySize(_ref, _ref2) {
+  var firstBaseShape = _ref.baseShape;
+  var secondBaseShape = _ref2.baseShape;
+
+  if (!firstBaseShape || !secondBaseShape) {
+    return 0;
+  }
+
+  var firstSize = firstBaseShape.width * firstBaseShape.height;
+  var secondSize = secondBaseShape.width * secondBaseShape.height;
+  return secondSize - firstSize;
+}

package/App/Reducers/Device/Actions.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resizeWindow = exports.RESIZE_WINDOW = void 0;
+var RESIZE_WINDOW = 'device/RESIZE_WINDOW';
+exports.RESIZE_WINDOW = RESIZE_WINDOW;
+
+var resizeWindow = function resizeWindow() {
+  return {
+    type: RESIZE_WINDOW
+  };
+};
+
+exports.resizeWindow = resizeWindow;

package/App/Reducers/Device/Reducer.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = deviceReducer;
+
+var _Actions = require("./Actions");
+
+var _isMobileDevice = require("redhotmagma-visualization/Utils/isMobileDevice");
+
+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 getScreenObject = function getScreenObject() {
+  var _window = window,
+      width = _window.innerWidth,
+      height = _window.innerHeight,
+      matchMedia = _window.matchMedia;
+  var orientation = matchMedia('(orientation: portrait)').matches ? 'portrait' : 'landscape';
+  return {
+    width: width,
+    height: height,
+    ratio: width / height,
+    orientation: orientation,
+    isMobileDevice: (0, _isMobileDevice.isMobileDevice)(),
+    isTabletDevice: (0, _isMobileDevice.isMobileDevice)() && Math.min(width, height) > 760
+  };
+};
+
+var initialState = {
+  screen: getScreenObject()
+};
+
+function deviceReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  switch (action.type) {
+    case _Actions.RESIZE_WINDOW:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        screen: getScreenObject()
+      });
+
+    default:
+      return state;
+  }
+}

package/App/Reducers/Fonts/Actions.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCustomFonts = exports.addCustomFont = exports.fetchFonts = exports.receiveFonts = exports.addFontFamilyToDOM = exports.ADD_FONTS = exports.ADD_FONT = exports.RECEIVE_FONTS = void 0;
+
+var _configuration = require("../../configuration");
+
+var _Actions = require("../Actions");
+
+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; }
+
+var RECEIVE_FONTS = 'RECEIVE_FONTS';
+exports.RECEIVE_FONTS = RECEIVE_FONTS;
+var ADD_FONT = 'ADD_FONT';
+exports.ADD_FONT = ADD_FONT;
+var ADD_FONTS = 'ADD_FONTS';
+exports.ADD_FONTS = ADD_FONTS;
+
+var addFontFamilyToDOM = function addFontFamilyToDOM(name, url, bold, italic) {
+  var fontFaceProperties = ['font-family: "' + name + '";', 'src: url("' + url + '");'];
+
+  if (bold) {
+    fontFaceProperties.push('font-weight: bold;');
+  }
+
+  if (italic) {
+    fontFaceProperties.push('font-style: italic;');
+  }
+
+  var style = document.createElement('style');
+  style.appendChild(document.createTextNode('@font-face { ' + fontFaceProperties.join(' ') + ' }'));
+  document.head.appendChild(style);
+};
+
+exports.addFontFamilyToDOM = addFontFamilyToDOM;
+
+var receiveFonts = function receiveFonts(data) {
+  return function (dispatch) {
+    var host = (0, _configuration.getConf)('network.host');
+    var fonts = [];
+
+    var _iterator = _createForOfIteratorHelper(data),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var customFont = _step.value;
+        var font = {
+          name: customFont.name,
+          family: customFont.name,
+          regular: false,
+          bold: false,
+          italic: false,
+          boldItalic: false,
+          isDefault: customFont.isDefault
+        };
+        var fontFields = [{
+          field: 'fileNameRegular',
+          property: 'regular',
+          bold: false,
+          italic: false
+        }, {
+          field: 'fileNameBold',
+          property: 'bold',
+          bold: true,
+          italic: false
+        }, {
+          field: 'fileNameItalic',
+          property: 'italic',
+          bold: false,
+          italic: true
+        }, {
+          field: 'fileNameBoldItalic',
+          property: 'boldItalic',
+          bold: true,
+          italic: true
+        }];
+
+        for (var _i = 0, _fontFields = fontFields; _i < _fontFields.length; _i++) {
+          var fontField = _fontFields[_i];
+          var fontPath = customFont[fontField.field];
+
+          if (fontPath) {
+            var fontUrl = host + fontPath;
+            var urlFieldName = 'url' + fontField.property.charAt(0).toUpperCase() + fontField.property.slice(1);
+            font[fontField.property] = true;
+            font[urlFieldName] = fontUrl;
+            addFontFamilyToDOM(font.family, fontUrl, fontField.bold, fontField.italic);
+          }
+        }
+
+        fonts.push(font);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    dispatch({
+      type: RECEIVE_FONTS,
+      data: fonts
+    });
+  };
+};
+
+exports.receiveFonts = receiveFonts;
+
+var fetchFonts = function fetchFonts() {
+  return (0, _Actions.fetchDataAsync)('designer/fonts', receiveFonts);
+};
+
+exports.fetchFonts = fetchFonts;
+
+var addCustomFont = function addCustomFont(customFont) {
+  return {
+    type: ADD_FONT,
+    data: customFont
+  };
+};
+
+exports.addCustomFont = addCustomFont;
+
+var addCustomFonts = function addCustomFonts(customFonts) {
+  return {
+    type: ADD_FONTS,
+    data: customFonts
+  };
+};
+
+exports.addCustomFonts = addCustomFonts;

package/App/Reducers/Fonts/Reducer.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fontsReducer = fontsReducer;
+exports["default"] = void 0;
+
+var _Actions = require("./Actions");
+
+var initialState = [];
+
+function fontsReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  switch (action.type) {
+    case _Actions.RECEIVE_FONTS:
+      return action.data;
+
+    case _Actions.ADD_FONT:
+      {
+        var customFont = action.data;
+        return state.concat(customFont);
+      }
+
+    case _Actions.ADD_FONTS:
+      {
+        var customFonts = action.data;
+        return state.concat(customFonts);
+      }
+
+    default:
+      return state;
+  }
+}
+
+var _default = fontsReducer;
+exports["default"] = _default;

package/App/Reducers/Fonts/Selectors.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultFont = getDefaultFont;
+exports.getUsedCustomFontsInEditor = getUsedCustomFontsInEditor;
+exports.getFontMapping = exports.getDefaultFontParams = void 0;
+
+var _first = _interopRequireDefault(require("lodash/first"));
+
+var _each = _interopRequireDefault(require("lodash/each"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _createSelector = _interopRequireDefault(require("../../../Utils/Function/createSelector"));
+
+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 escapeQuotes = function escapeQuotes(str) {
+  return str.replace(/(['"])/g, '\\$1');
+};
+
+function getDefaultFont(state) {
+  var fonts = state.fonts;
+  return (0, _find["default"])(fonts, {
+    isDefault: true
+  }) || (0, _first["default"])(fonts);
+}
+
+var getDefaultFontParams = function getDefaultFontParams(state) {
+  var stringify = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var defaultFont = getDefaultFont(state);
+  var fontParams = {
+    'font-family': "\"".concat(escapeQuotes(defaultFont.family), "\""),
+    'font-weight': 'normal',
+    'font-style': 'normal'
+  };
+  return stringify ? Object.keys(fontParams).map(function (prop) {
+    return "".concat(prop, ": ").concat(fontParams[prop], ";");
+  }).join(' ') : fontParams;
+};
+
+exports.getDefaultFontParams = getDefaultFontParams;
+var getFontMapping = (0, _createSelector["default"])(function (_ref) {
+  var fonts = _ref.fonts;
+  return fonts;
+}, function (fonts) {
+  var typeToUrlProp = {
+    regular: 'urlRegular',
+    bold: 'urlBold',
+    italic: 'urlItalic',
+    boldItalic: 'urlBoldItalic'
+  };
+  var typeKeys = Object.keys(typeToUrlProp);
+  var fontMapping = {};
+  (0, _each["default"])(fonts, function (font) {
+    fontMapping[font.family] = {};
+    (0, _each["default"])(typeKeys, function (typeKey) {
+      var fontUrl = font[typeToUrlProp[typeKey]];
+
+      if (fontUrl) {
+        fontMapping[font.family][typeKey] = fontUrl;
+      }
+    });
+  });
+  return fontMapping;
+});
+exports.getFontMapping = getFontMapping;
+
+function getUsedCustomFontsInEditor(state) {
+  var usedCustomFonts = [];
+  var designdata = (0, _get["default"])(state, 'configurator.configuration.designdata') || {};
+  Object.values(designdata).forEach(function (designAreaData) {
+    var objects = (0, _get["default"])(designAreaData, 'canvasData.objects') || [];
+    objects.filter(function (_ref2) {
+      var type = _ref2.type;
+      return type === 'Text';
+    }).forEach(function (_ref3) {
+      var fontItem = _ref3.fontItem;
+
+      if (fontItem.isCustomFont) {
+        var customFontObj = _objectSpread(_objectSpread({}, getDefaultFont(state)), fontItem);
+
+        !(0, _find["default"])(usedCustomFonts, customFontObj) && usedCustomFonts.push(customFontObj);
+      }
+    });
+  });
+  return usedCustomFonts;
+}