@configuratorware/configurator-frontendgui 1.28.1 → 1.29.0

package/App/Screens/DesignerProductPreview/DesignerProductPreviewManager.js

@@ -0,0 +1,554 @@
+"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.createDesignerProductPreviewManager = createDesignerProductPreviewManager;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var storage = _interopRequireWildcard(require("../../Storage"));
+
+var _Constants = require("./Constants");
+
+var _ServiceLocator = require("../../ServiceLocator");
+
+var _Selectors = require("../../Reducers/DesignArea/Selectors");
+
+var _Selectors2 = require("../../Reducers/Configurator/Selectors");
+
+var _Actions = require("../../Reducers/ImageGallery/Actions");
+
+var _Modifiers = require("../../Reducers/DesignData/Modifiers");
+
+var _DesignDataService = require("../../Services/DesignDataService");
+
+var _getFirstDataURLFromScreenshotsObj = require("../../Modules/Visualization/Utils/getFirstDataURLFromScreenshotsObj");
+
+var _createMessageInterface = _interopRequireDefault(require("../../Utils/createMessageInterface"));
+
+var _excluded = ["event"];
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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); }); }; }
+
+/**
+ * A helper function that prepares the image data to be used on the design area
+ * In case of design production methods with embroidery effect it also creates the color map for the image,
+ * so it can be shown as it was added from the image edit dialog.
+ * It uses memoization in order to minimize the execution time for repeated requests
+ */
+var prepareImageData = function createImageDataPreProcessor() {
+  var lastHash;
+  var imageDataMemo = new Map();
+
+  function getImageDataHash(imageData) {
+    return JSON.stringify(['identifier', 'preview.url', 'operations.clipping', 'operations.clippingColor'].map(function (prop) {
+      return (0, _get["default"])(imageData, prop);
+    }));
+  }
+
+  return /*#__PURE__*/function () {
+    var _prepareImageData = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(designArea, imageData) {
+      var hash, state, designProductionMethod, patchedImageData, colorPreviewRequired, svgContent, svgColors, vectorizeColorsMap;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              hash = getImageDataHash(imageData);
+
+              if (hash !== lastHash) {
+                lastHash = hash;
+                imageDataMemo.clear();
+              }
+
+              state = _ServiceLocator.Services.store.state;
+              designProductionMethod = (0, _Selectors.getSelectedDesignProductionMethodForDesignArea)(state, designArea);
+
+              if (!imageDataMemo.has(designProductionMethod.identifier)) {
+                _context.next = 6;
+                break;
+              }
+
+              return _context.abrupt("return", imageDataMemo.get(designProductionMethod.identifier));
+
+            case 6:
+              colorPreviewRequired = (0, _Selectors.designProductionMethodHasEmbroideryVisualizationEffect)(designProductionMethod);
+
+              if (!colorPreviewRequired) {
+                _context.next = 16;
+                break;
+              }
+
+              _context.next = 10;
+              return (0, _DesignDataService.getSvgContent)(imageData.preview.url, false, true);
+
+            case 10:
+              svgContent = _context.sent;
+              svgColors = (0, _DesignDataService.getSvgColors)(svgContent, designProductionMethod);
+              vectorizeColorsMap = (0, _Modifiers.createVectorizeColorsMap)({}, svgColors);
+              patchedImageData = _objectSpread(_objectSpread({}, imageData), {}, {
+                colorPreviewRequired: true,
+                displayColorPreview: true,
+                colorPreviewEnabled: true,
+                operations: _objectSpread(_objectSpread({}, imageData.operations), {}, {
+                  vectorizeColorsMap: vectorizeColorsMap
+                })
+              });
+              _context.next = 17;
+              break;
+
+            case 16:
+              // the color replacement call returns the same url for every call, making the browser serve the image
+              // from cache, to force reloading a random query string has to be added to the url
+              patchedImageData = _objectSpread(_objectSpread({}, imageData), {}, {
+                preview: _objectSpread(_objectSpread({}, imageData.preview), {}, {
+                  url: imageData.preview.url.replace(/svg|png$/, "png?".concat(Math.random()))
+                })
+              });
+
+            case 17:
+              imageDataMemo.set(designProductionMethod.identifier, patchedImageData);
+              return _context.abrupt("return", patchedImageData);
+
+            case 19:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function prepareImageData(_x, _x2) {
+      return _prepareImageData.apply(this, arguments);
+    }
+
+    return prepareImageData;
+  }();
+}();
+/**
+ * Creates a preview item object, which is responsible for
+ *  - loading the product,
+ *  - adding the image to the design area,
+ *  - creating the preview image
+ *  - additionally it helps to control the flow
+ * @param identifier
+ * @param event
+ */
+
+
+function createPreviewItem(identifier, event) {
+  var PreviewItemStatus = {
+    pending: 1,
+    loading: 2,
+    loaded: 3,
+    screenshotting: 4,
+    finished: 5
+  };
+  var status = PreviewItemStatus.pending;
+  var image;
+  var error;
+  /**
+   * @return {Promise<void>}
+   */
+
+  function load() {
+    return _load.apply(this, arguments);
+  }
+  /**
+   * @param {object} imageData
+   * @param {object} size
+   * @return {Promise<{identifier: string, image: string, error: string, event: *}|undefined>}
+   */
+
+
+  function _load() {
+    _load = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              status = PreviewItemStatus.loading;
+              _context2.prev = 1;
+
+              _ServiceLocator.Services.configurator.setLoadIdentifier(identifier);
+
+              _context2.next = 5;
+              return _ServiceLocator.Services.configurator.loadConfigurationForDesignerProductPreview();
+
+            case 5:
+              status = PreviewItemStatus.loaded;
+              _context2.next = 12;
+              break;
+
+            case 8:
+              _context2.prev = 8;
+              _context2.t0 = _context2["catch"](1);
+              error = _context2.t0.toString();
+              status = PreviewItemStatus.finished;
+
+            case 12:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[1, 8]]);
+    }));
+    return _load.apply(this, arguments);
+  }
+
+  function createImage(_x3, _x4) {
+    return _createImage.apply(this, arguments);
+  }
+
+  function _createImage() {
+    _createImage = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(imageData, size) {
+      var state, filteredDesignAreas, defaultDesignAreaIdentifier, designArea, areaList, viewList, variantList, screenshot;
+      return regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!(status === PreviewItemStatus.loaded)) {
+                _context3.next = 4;
+                break;
+              }
+
+              status = PreviewItemStatus.screenshotting;
+              _context3.next = 5;
+              break;
+
+            case 4:
+              return _context3.abrupt("return");
+
+            case 5:
+              _context3.prev = 5;
+              state = _ServiceLocator.Services.store.state;
+              filteredDesignAreas = state.designArea.filteredDesignAreas;
+              defaultDesignAreaIdentifier = (0, _Selectors.getDefaultDesignAreaIdentifierFromProductionMethod)(state);
+              designArea = filteredDesignAreas.find(function (_ref) {
+                var identifier = _ref.identifier;
+                return identifier === defaultDesignAreaIdentifier;
+              }) || filteredDesignAreas[0];
+              areaList = designArea ? [designArea.identifier] : [];
+              viewList = (0, _Selectors.getCameraViewListForDesignAreaList)(filteredDesignAreas, areaList);
+              variantList = [(0, _Selectors2.getSelectedVariantIdentifier)(state.configurator)];
+
+              _ServiceLocator.Services.designData.toggleHighlight(false, false);
+
+              if (!designArea) {
+                _context3.next = 22;
+                break;
+              }
+
+              _context3.t0 = _ServiceLocator.Services.designData;
+              _context3.t1 = designArea;
+              _context3.next = 19;
+              return prepareImageData(designArea, imageData);
+
+            case 19:
+              _context3.t2 = _context3.sent;
+              _context3.next = 22;
+              return _context3.t0.addImageToDesignArea.call(_context3.t0, _context3.t1, _context3.t2);
+
+            case 22:
+              _context3.next = 24;
+              return _ServiceLocator.Services.visualization.getScreenshots({
+                areaList: areaList,
+                viewList: viewList,
+                variantList: variantList,
+                size: size
+              });
+
+            case 24:
+              screenshot = _context3.sent;
+              image = (0, _getFirstDataURLFromScreenshotsObj.getFirstDataURLFromScreenshotsObj)(screenshot);
+              status = PreviewItemStatus.finished;
+              _context3.next = 33;
+              break;
+
+            case 29:
+              _context3.prev = 29;
+              _context3.t3 = _context3["catch"](5);
+              error = _context3.t3.toString();
+              status = PreviewItemStatus.finished;
+
+            case 33:
+              return _context3.abrupt("return", {
+                identifier: identifier,
+                image: image,
+                error: error,
+                event: event
+              });
+
+            case 34:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, null, [[5, 29]]);
+    }));
+    return _createImage.apply(this, arguments);
+  }
+
+  return {
+    load: load,
+    createImage: createImage,
+    isFinished: function isFinished() {
+      return status === PreviewItemStatus.finished;
+    }
+  };
+}
+/**
+ * Helper interface for localStorage
+ * @param {object} options
+ */
+
+
+function createStorage() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$localStorage = options.localStorage,
+      localStorage = _options$localStorage === void 0 ? storage : _options$localStorage;
+  return {
+    /**
+     * @param {string} key
+     * @param {any} value
+     */
+    set: function set(key, value) {
+      localStorage.local.setItem(key, JSON.stringify(value));
+    },
+
+    /**
+     * @param {string} key
+     * @return {any}
+     */
+    get: function get(key) {
+      try {
+        var serializedValue = localStorage.local.getItem(key);
+        return serializedValue && JSON.parse(serializedValue);
+      } catch (e) {// ignore errors
+      }
+    }
+  };
+}
+/**
+ * Provides interface to both the container window (with postMessage API) and the React component
+ * Further responsibilities:
+ *  - stores the applied image in localStorage or in memory if not available and restores it on page load
+ *  - hooks into the visualization service to get notified when it is ready to create the preview image
+ * @param {object} options
+ */
+
+
+function createDesignerProductPreviewManager() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$localStorage2 = options.localStorage,
+      localStorage = _options$localStorage2 === void 0 ? createStorage() : _options$localStorage2,
+      _options$messageInter = options.messageInterface,
+      messageInterface = _options$messageInter === void 0 ? (0, _createMessageInterface["default"])() : _options$messageInter;
+  var currentImageData = localStorage.get(_Constants.imageDataKey);
+  var size = {
+    width: 200,
+    height: 200
+  };
+  var currentItem;
+  var previewRequests = [];
+  var previewStack = []; //// actions provided for the container window
+
+  /**
+   * Usage from the container window:
+   * configuratorIframe.postMessage({
+   *   type: 'setItemIdentifiers',
+   *   identifiers: ['product1', 'product2', ...]
+   * })
+   * @param event
+   */
+
+  messageInterface.addListener('setItemIdentifiers', function setItemIdentifiers(event) {
+    previewRequests.length = 0; // clear all previous element
+
+    var identifiers = (0, _get["default"])(event, 'data.identifiers') || [];
+    identifiers.forEach(function (identifier) {
+      previewRequests.push({
+        identifier: identifier,
+        event: event
+      });
+    }); // if image is available, update products when new identifiers arrive
+
+    if ((0, _get["default"])(currentImageData, 'preview.url')) {
+      updateImages();
+    }
+  });
+  /**
+   * Usage from the container window:
+   * configuratorIframe.postMessage({
+   *   type: 'setSize',
+   *   size: { width: 800, height: 600 }
+   * })
+   * @param event
+   */
+
+  messageInterface.addListener('setSize', function setSize(event) {
+    var width = +(0, _get["default"])(event, 'data.size.width');
+    var height = +(0, _get["default"])(event, 'data.size.height');
+
+    if (width) {
+      size.width = width;
+    }
+
+    if (height) {
+      size.height = height;
+    }
+  }); //// actions dispatched to the container window
+  // notifies the origin if a preview image is ready to be shown
+
+  function dispatchPreviewItem(screenshotItem) {
+    var event = screenshotItem.event,
+        previewData = _objectWithoutProperties(screenshotItem, _excluded);
+
+    messageInterface.dispatch(_objectSpread({
+      type: 'configuratorware_designer_preview_widget_dataready'
+    }, previewData), {
+      targetWindow: event.source
+    });
+  } // tells the container window the preview widget is ready and started listening for actions
+
+
+  function dispatchLoaded() {
+    messageInterface.dispatch({
+      type: 'configuratorware_designer_preview_widget_loaded'
+    });
+  } //// flow control helpers
+
+
+  function processNextProduct() {
+    setTimeout(function () {
+      if (currentItem && !currentItem.isFinished()) {
+        return;
+      }
+
+      currentItem = previewStack.pop();
+
+      if (!currentItem) {
+        _ServiceLocator.Services.ui.hide(_Constants.loaderKey);
+
+        return;
+      }
+
+      currentItem.load();
+    });
+  }
+
+  function createPreviewImage() {
+    return _createPreviewImage.apply(this, arguments);
+  }
+
+  function _createPreviewImage() {
+    _createPreviewImage = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4() {
+      var previewItem;
+      return regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              if (currentItem) {
+                _context4.next = 3;
+                break;
+              }
+
+              processNextProduct();
+              return _context4.abrupt("return");
+
+            case 3:
+              _context4.next = 5;
+              return currentItem.createImage(currentImageData, size);
+
+            case 5:
+              previewItem = _context4.sent;
+
+              if (!(!currentItem.isFinished() || !previewItem)) {
+                _context4.next = 8;
+                break;
+              }
+
+              return _context4.abrupt("return");
+
+            case 8:
+              dispatchPreviewItem(previewItem);
+              processNextProduct();
+
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+    return _createPreviewImage.apply(this, arguments);
+  }
+
+  function updateImages() {
+    currentItem = null;
+
+    _ServiceLocator.Services.ui.show(_Constants.loaderKey);
+
+    previewRequests.forEach(function (_ref2) {
+      var identifier = _ref2.identifier,
+          event = _ref2.event;
+      previewStack.push(createPreviewItem(identifier, event));
+    });
+    processNextProduct();
+  } //// the public interface provided to the React component
+
+  /**
+   * @param {function} [options.onRestoreImage]
+   */
+
+
+  function init() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var onRestoreImage = options.onRestoreImage; // first rendering triggers the preview image creation
+
+    _ServiceLocator.Services.visualization.registerVisualizationUpdateListener(createPreviewImage); // restore the image data directly (if there is any)
+
+
+    currentImageData && _ServiceLocator.Services.store.dispatch((0, _Actions.setSelectedImageData)(currentImageData));
+    currentImageData && onRestoreImage && setTimeout(function () {
+      return onRestoreImage(currentImageData);
+    });
+    dispatchLoaded();
+  }
+  /**
+   * @param {object} [imageData]
+   */
+
+
+  function useImage() {
+    var imageData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _ServiceLocator.Services.store.state.imageGallery.selectedImage;
+    currentImageData = imageData;
+    localStorage.set(_Constants.imageDataKey, imageData);
+    previewRequests.length && updateImages();
+  }
+
+  return {
+    init: init,
+    useImage: useImage
+  };
+}