@configuratorware/configurator-frontendgui 1.28.3 → 1.29.1

package/App/configuration.js

@@ -0,0 +1,421 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init = init;
+exports.getQueryParams = getQueryParams;
+exports.setConfiguration = setConfiguration;
+exports.getConf = getConf;
+exports.setConf = setConf;
+exports.getComponent = getComponent;
+exports.isProduction = isProduction;
+exports.getCustomApplicationConfiguration = exports.setCustomApplicationConfiguration = exports.WidgetAfterSaveMethods = exports.SaveTypes = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _Api = _interopRequireDefault(require("../Framework/Api"));
+
+var _Translations = require("./Translations");
+
+var _hyphenatedDe = _interopRequireDefault(require("hyphenated-de"));
+
+var _hyphenatedEnGb = _interopRequireDefault(require("hyphenated-en-gb"));
+
+var _Reducer = require("./Reducers/Configurator/Reducer");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var DEVELOPMENT_HOST_INT = 'http://int.configuratorware.local'; // eslint-disable-next-line no-unused-vars
+
+var DEVELOPMENT_HOST_LOCAL = 'http://localhost:10030';
+var hostsByNodeEnv = {
+  production: '',
+  development: DEVELOPMENT_HOST_INT,
+  test: ''
+};
+var resourceUrlsByNodeEnv = {
+  production: '',
+  development: DEVELOPMENT_HOST_INT,
+  test: ''
+};
+var host = hostsByNodeEnv[process.env.NODE_ENV];
+var resourcesURL = resourceUrlsByNodeEnv[process.env.NODE_ENV];
+var network = {
+  host: host,
+  baseURL: "".concat(host, "/frontendapi/"),
+  resourcesURL: resourcesURL,
+  timeout: 60000
+};
+var SaveTypes = {
+  USER: 'user',
+  DEFAULTOPTIONS: 'defaultoptions',
+  INSPIRATION: 'inspiration',
+  CART: 'cart',
+  MAIL: 'mail',
+  SHARE: 'share',
+  LANGUAGESWITCH: 'languageswitch',
+  CHANNELSWITCH: 'channelswitch',
+  PRINT: 'print',
+  DESIGNTEMPLATE: 'designtemplate',
+  OFFERREQUEST: 'offer_request',
+  WIDGET: 'widget'
+};
+exports.SaveTypes = SaveTypes;
+var WidgetAfterSaveMethods = {
+  OpenNewWindow: 'openNewWindow',
+  PostMessage: 'postMessage'
+};
+exports.WidgetAfterSaveMethods = WidgetAfterSaveMethods;
+var applicationConfiguration = {
+  network: network,
+  // the default language code (format: de-DE, en-GB, etc.), use false to select the browser language
+  language: false,
+  // the available locales
+  locales: [{
+    code: 'de_DE',
+    preferred: true
+  }, {
+    code: 'en_GB'
+  }],
+  hyphenations: {
+    'de-DE': _hyphenatedDe["default"],
+    'en-GB': _hyphenatedEnGb["default"]
+  },
+  // array of configuration save types
+  saveTypes: SaveTypes,
+  // show custom title input before saving the configuration
+  editCustomTitleBeforeSave: false,
+  // default: false
+  // which types need a custom title before saving?
+  customTitleSaveTypes: [SaveTypes.DESIGNTEMPLATE, SaveTypes.INSPIRATION],
+  // set true to load available variants before loading the configuration
+  loadVariantsFirst: false,
+  // default: false
+  // set true to load
+  loadInspirations: false,
+  // default: false
+  // set true to open the first optionclassification instead of the "start here" text
+  showInitialOptionclassification: false,
+  // default: false
+  // show the "start here" animation
+  showStartHere: true,
+  // show the "add to cart" button by default
+  showAddToCartButton: true,
+  // set true to run server-side validation before addToCart
+  validateBeforeCTA: true,
+  // set false to decide by screen orientation, or can be fixed 'left' or 'bottom'
+  dock: false,
+  // set true to display the selected option for each optionclassification
+  displaySwitchedOptions: false,
+  // default: false
+  // set true to check the optionclassification immediately after selected
+  checkOptionclassificationOnSelect: false,
+  // which method is used for addToCart? default: postMessage
+  // when it is set to 'functionCall' it calls window.parent.addToCart(configuration.code)
+  addToCartMethod: 'postMessage',
+  // use carousel for optionclassification list
+  optionclassificationCarousel: true,
+  // set true to disable beforeunload warning
+  disableBeforeunloadWarning: false,
+  // set true to hide optionlist when user clicks somewhere else
+  hideOptionListOnAwayClick: true,
+  // set true to force the option details dialog shown with an image
+  optionDetailsWithImage: false,
+  // set true to disable optionlist moving
+  fixedOptionlist: false,
+  //set true to show accept design checkbox approval
+  displayAcceptDesign: true,
+  // available tools in the toolbar
+  availableTools: {
+    fastConfiguration: false,
+    save: true,
+    load: true,
+    share: true,
+    print: true
+  },
+  // relative position of the option list dialog
+  // [
+  //   [<dialogSideH{left|center|right}>, <relToSideH{left|center|right}>],
+  //   [<dialogSideV{top|center|bottom}>, <relToSideV{top|center|bottom}>]
+  // ]
+  optionlistDialogPositioning: {
+    left: [['left', 'right'], ['top', 'top']],
+    bottom: [['center', 'center'], ['bottom', 'top']]
+  },
+  // override this to set a default item identifier to load if not defined in the route
+  defaultLoadIdentifier: false,
+  // should the option list be fixed to the left side, or it can open up above the selected option classification
+  optionListFixedToLeft: true,
+  // the components used in the Screen (override any component in custom project)
+  components: {},
+  // the containers used in the Screen (override any container in custom project)
+  containers: {},
+  // load the available configuration modes (might be set to false in older configurators)
+  loadConfigurationModes: true,
+  // if set to false only the amount for the currently selected variant can be selected
+  // when switching the variant the selected amount is transferred to the newly selected variant
+  restrictAmountselectionToSelectedVariant: false,
+  displayColorAmountWarnings: true,
+  displayEditorRulers: true,
+  // default options for opening the configurator (eg. after saved from the calculation widget)
+  openConfigurator: {
+    method: WidgetAfterSaveMethods.OpenNewWindow // when the PostMessage mode is used the targetOrigin can be specified, otherwise '*' will be used
+
+  },
+  visualization: {
+    designAreaHighlightBackgroundColor: 'transparent'
+  },
+  designer: {
+    dpi: 300,
+    // the default canvas dpi as project specific option
+    maxColorAmount: 10 // the default max number of colors in the colorizing feature
+
+  },
+  vectorizeImageQuality: 45000,
+  renderPreviewImagesForCheckout: true,
+  // automatically show the vectorization preview in colorizing step
+  autoPreviewVectorization: true,
+  // switch to the previously selected view when selecting a component that has no view specified
+  switchViewOnComponentSelection: true,
+  // the visualization behaves like it was a mask over the designer canvas
+  visualizationOverlayMode: false
+};
+/**
+ * document.domain can be set via a GET Param or is defaulted to
+ * the (subdomain.)secondlevel.tld (subdamain cut out)
+ */
+
+function setDocumentDomain() {
+  var query = new URLSearchParams(location.search);
+  var parts = window.location.hostname.split('.');
+  var domain = query.get('_documentdomain');
+
+  if (!domain) {
+    if (parts.length > 1) {
+      // get domain.tld at max
+      parts = parts.reverse();
+      domain = parts[1] + '.' + parts[0];
+    } else {
+      domain = window.location.hostname;
+    }
+  }
+
+  try {
+    document.domain = domain;
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.log('WARNING: document.domain could not be set');
+  }
+}
+
+function preventLeavingPage() {
+  if (process.env.NODE_ENV === 'production' && !getConf('adminMode')) {
+    // registering beforeunload event
+    // in dev mode it prevents the hot reloading, use only in production mode
+    if (!getConf('disableBeforeunloadWarning')) {
+      window.addEventListener('beforeunload', function (e) {
+        // disableBeforeunloadWarning is checked again, so that it can be disabled during runtime (after mount)
+        if (getConf('disableBeforeunloadWarning')) {
+          return false;
+        } else {
+          var confirmationMessage = 'Are you sure?'; // this message will not be shown
+
+          e.returnValue = confirmationMessage; // Gecko, Trident, Chrome 34+
+
+          return confirmationMessage; // Gecko, WebKit, Chrome <34
+        }
+      });
+    }
+  }
+}
+
+function init() {
+  applicationConfiguration = _lodash["default"].merge(applicationConfiguration, getQueryParams());
+
+  _Api["default"].init(applicationConfiguration.network);
+
+  setLanguage();
+  setDocumentDomain();
+  preventLeavingPage();
+  return applicationConfiguration;
+}
+
+function getQueryParams() {
+  var query = new URLSearchParams(location.search);
+  var queryConf = {}; // if the language is in the params, set it from there
+
+  if (query.has('_language')) {
+    queryConf.language = query.get('_language').replace('_', '-');
+  }
+
+  if (query.has('_channel')) {
+    var channel = query.get('_channel');
+    queryConf.channel = channel;
+
+    _Api["default"].setChannel(channel);
+  } // hide variants selection
+
+
+  if (query.has('_hidevariantselection') && query.get('_hidevariantselection') === 'true') {
+    queryConf.loadVariantsFirst = false;
+  } // admin modes
+
+
+  if (query.has('_adminmode')) {
+    queryConf.adminMode = query.get('_adminmode');
+  }
+
+  if (query.has('_adminapitoken')) {
+    queryConf.adminApiToken = query.get('_adminapitoken');
+  } // add reference to parent when saving (normally used when coming back from the cart)
+
+
+  if (query.has('_addparentcodeonsave')) {
+    queryConf.addParentCodeOnSave = true;
+  }
+
+  if (query.has('_share_url')) {
+    _Api["default"].setGETParameter('_share_url', encodeURIComponent(query.get('_share_url')));
+  }
+
+  if (query.has('_designerPreSelection')) {
+    try {
+      queryConf.designerPreSelection = JSON.parse(query.get('_designerPreSelection'));
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('_designerPreSelection parse error', e);
+    }
+  }
+
+  if (query.has('_frombasket')) {
+    queryConf.fromBasket = query.get('_frombasket') === '1';
+  }
+
+  if (query.has('_admin_mode_hash')) {
+    _Api["default"].setGETParameter('_admin_mode', query.get('_admin_mode_hash'));
+  }
+
+  if (query.has('_client')) {
+    _Api["default"].setGETParameter('_client', query.get('_client'));
+  }
+
+  if (query.has('_display_net_prices') && query.get('_display_net_prices') === '1') {
+    queryConf.displayNetPrices = true;
+
+    _Api["default"].setGETParameter('_display_net_prices', query.get('_display_net_prices'));
+  }
+
+  if (query.has('_configuration_mode')) {
+    queryConf.configurationMode = query.get('_configuration_mode');
+  }
+
+  if (query.has('_cta_element')) {
+    _Api["default"].setGETParameter('_cta_element', query.get('_cta_element'));
+  }
+
+  if (query.has('_hide_prices')) {
+    _Api["default"].setGETParameter('_hide_prices', query.get('_hide_prices'));
+  }
+
+  if (query.has('_switch_options')) {
+    var optionsToSwitchJSON = query.get('_switch_options');
+
+    try {
+      queryConf.selectOptions = JSON.parse(optionsToSwitchJSON);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('Wrong JSON provided for _switch_options:', optionsToSwitchJSON);
+    }
+  }
+
+  return queryConf;
+}
+
+function setConfiguration(customApplicationConfiguration) {
+  applicationConfiguration = _lodash["default"].merge(applicationConfiguration, customApplicationConfiguration, getQueryParams());
+  setLanguage(); // if there is a config for network Api instance defaults must be updated
+
+  if (applicationConfiguration.network) {
+    _Api["default"].init(applicationConfiguration.network);
+  } // set possible sub reducers and state change reducers
+
+
+  if (_lodash["default"].get(applicationConfiguration, 'reducers.configurator')) {
+    var _applicationConfigura = applicationConfiguration.reducers.configurator,
+        subReducers = _applicationConfigura.subReducers,
+        stateChangeReducers = _applicationConfigura.stateChangeReducers;
+    (0, _Reducer.setSubReducers)(subReducers);
+    (0, _Reducer.setStateChangeReducers)(stateChangeReducers);
+  }
+}
+
+function setLanguage() {
+  var language; // if the default language is defined in the configuration
+
+  if (applicationConfiguration.language) {
+    language = applicationConfiguration.language;
+  } // if there is a locales array in the configuration...
+  else if (applicationConfiguration.locales) {
+    var browserLanguage = _lodash["default"].get(navigator, 'languages[0]', navigator.language).replace('-', '_');
+
+    var matchToBrowserLanguage = _lodash["default"].find(applicationConfiguration.locales, {
+      code: browserLanguage
+    });
+
+    var preferred = _lodash["default"].find(applicationConfiguration.locales, {
+      preferred: true
+    }); // if there is a match with the browser language use that
+
+
+    if (matchToBrowserLanguage) {
+      language = matchToBrowserLanguage.code;
+    } // if the preferred language is set use it
+    else if (preferred) {
+      language = preferred.code;
+    } // otherwise use the first from the locales list
+    else {
+      language = _lodash["default"].first(applicationConfiguration.locales).code;
+    }
+  } // we have no info about the language, so try to use the browser language
+  else {
+    language = _lodash["default"].get(navigator, 'languages[0]', navigator.language).replace('-', '_') || 'de_DE';
+  }
+
+  if (!_lodash["default"].find(applicationConfiguration.locales, {
+    code: language
+  })) {
+    // eslint-disable-next-line no-console
+    console.warn("The selected language (".concat(language, ") is not listed in the available languages!"));
+  }
+
+  applicationConfiguration.language = language.replace('_', '-');
+
+  _Api["default"].setLanguage(applicationConfiguration.language);
+
+  (0, _Translations.initLanguage)(applicationConfiguration.language);
+} // backward compatibility alias
+
+
+var setCustomApplicationConfiguration = setConfiguration;
+exports.setCustomApplicationConfiguration = setCustomApplicationConfiguration;
+
+function getConf(path, dflt) {
+  return path ? _lodash["default"].get(applicationConfiguration, path, dflt) : applicationConfiguration;
+}
+
+function setConf(path, value) {
+  _lodash["default"].set(applicationConfiguration, path, value);
+} // backward compatibility alias
+
+
+var getCustomApplicationConfiguration = getConf;
+exports.getCustomApplicationConfiguration = getCustomApplicationConfiguration;
+
+function getComponent(name) {
+  return getConf("components.".concat(name));
+}
+
+function isProduction() {
+  return process.env.NODE_ENV === 'production';
+}

package/App/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.main = exports.render = exports.App = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _reactRedux = require("react-redux");
+
+require("./setup");
+
+require("./versionInfo");
+
+var _initServices = require("./initServices");
+
+var _Routing = _interopRequireDefault(require("./Routing"));
+
+var _Store = require("./Store");
+
+var _ServiceLocator = require("./ServiceLocator");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var App = function App() {
+  return /*#__PURE__*/_react["default"].createElement(_reactRedux.Provider, {
+    store: _Store.store
+  }, /*#__PURE__*/_react["default"].createElement(_Routing["default"], null));
+};
+
+exports.App = App;
+
+var render = function render() {
+  _reactDom["default"].render( /*#__PURE__*/_react["default"].createElement(App, null), document.getElementById('root'));
+};
+
+exports.render = render;
+
+var main = function main() {
+  var services = (0, _initServices.initServices)();
+
+  _ServiceLocator.Services.store.setStore(_Store.store);
+
+  services.configurator.initialize();
+};
+
+exports.main = main;
+var _default = App;
+exports["default"] = _default;

package/App/initServices.js

@@ -0,0 +1,67 @@
+"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"] = exports.initServices = void 0;
+
+var _ServiceLocator = _interopRequireWildcard(require("./ServiceLocator"));
+
+var _configuration = require("./configuration");
+
+var _StoreService = _interopRequireDefault(require("../Framework/Services/StoreService"));
+
+var _UIService = _interopRequireDefault(require("./Services/UIService"));
+
+var _AsyncService = _interopRequireDefault(require("../Framework/Services/AsyncService"));
+
+var _ConfiguratorService = _interopRequireDefault(require("./Services/ConfiguratorService"));
+
+var _InteractionService = _interopRequireDefault(require("./Services/InteractionService"));
+
+var _AdminareaCommunicationService = _interopRequireDefault(require("./Services/AdminareaCommunicationService"));
+
+var _VisualizationService = _interopRequireDefault(require("./Services/VisualizationService"));
+
+var _DesignDataService = _interopRequireDefault(require("./Services/DesignDataService"));
+
+var _AnalyticsService = _interopRequireDefault(require("./Services/AnalyticsService"));
+
+var _DesignerService = _interopRequireDefault(require("./Services/DesignerService"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _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 initServices = function initServices() {
+  var services = _objectSpread({
+    StoreService: _StoreService["default"],
+    UIService: _UIService["default"],
+    AsyncService: _AsyncService["default"],
+    ConfiguratorService: _ConfiguratorService["default"],
+    InteractionService: _InteractionService["default"],
+    AdminareaCommunicationService: _AdminareaCommunicationService["default"],
+    VisualizationService: _VisualizationService["default"],
+    DesignDataService: _DesignDataService["default"],
+    AnalyticsService: _AnalyticsService["default"],
+    DesignerService: _DesignerService["default"]
+  }, (0, _configuration.getConf)('services'));
+
+  _ServiceLocator["default"].useServiceMap(services);
+
+  return _ServiceLocator.Services;
+};
+
+exports.initServices = initServices;
+var _default = initServices;
+exports["default"] = _default;

package/App/setup.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _configuration = require("./configuration");
+
+if (process.env.NODE_ENV === 'production') {
+  // disable console in production mode
+  if (!window.console) {
+    window.console = {
+      error: function error() {}
+    };
+  }
+
+  var _console = window.console;
+
+  _console.log = _console.info = _console.warn = _console.timeEnd = _console.time = _console.group = _console.groupEnd = function () {}; // keep console.error to make them visible in prod too
+
+} else {
+  // eslint-disable-next-line no-console
+  console.log('* dev mode, console is enabled.');
+}
+
+(0, _configuration.init)();

package/App/versionInfo.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var versionInfo = process.env.FRONTENDGUI_VERSION;
+var versionTag = document.createElement('meta');
+versionTag.name = 'frontendgui-version';
+versionTag.content = versionInfo;
+window.document.head.insertAdjacentElement('afterbegin', versionTag);
+window.frontendguiVersion = versionInfo;