@configuratorware/configurator-frontendgui 1.28.5 → 1.29.2

package/Utils/Async/Deferred.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DeferredError", {
+  enumerable: true,
+  get: function get() {
+    return _DeferredError["default"];
+  }
+});
+exports.DeferredGroup = exports["default"] = exports.Deferred = void 0;
+
+var _DeferredError = _interopRequireDefault(require("../../Shared/ErrorTypes/DeferredError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+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; }
+
+/**
+ * @private
+ * @type {{}}
+ */
+var promises = {};
+
+var Deferred = /*#__PURE__*/function () {
+  function Deferred() {
+    var _this = this;
+
+    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    _classCallCheck(this, Deferred);
+
+    _defineProperty(this, "resolve", function () {
+      _this.remove();
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this._resolve.apply(0, args);
+    });
+
+    _defineProperty(this, "reject", function () {
+      _this.remove();
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      _this._reject.apply(0, args);
+    });
+
+    if (promises[name]) {
+      throw new _DeferredError["default"]('Instance already exists with the name: ' + name);
+    }
+
+    this.name = name;
+    this.promise = new Promise(function (resolve, reject) {
+      _this._resolve = resolve;
+      _this._reject = reject;
+    });
+
+    if (name) {
+      promises[name] = this;
+    }
+  }
+
+  _createClass(Deferred, [{
+    key: "remove",
+    value: function remove() {
+      delete promises[this.name];
+    }
+  }, {
+    key: "then",
+    value: function then(fn) {
+      this.promise.then(fn);
+    }
+  }], [{
+    key: "get",
+    value: function get(name) {
+      if (!promises[name]) {
+        throw new _DeferredError["default"]('Instance does not exist with the name: ' + name);
+      }
+
+      return promises[name];
+    }
+  }]);
+
+  return Deferred;
+}();
+
+exports.Deferred = Deferred;
+var _default = Deferred;
+exports["default"] = _default;
+
+var DeferredGroup = /*#__PURE__*/function () {
+  function DeferredGroup() {
+    _classCallCheck(this, DeferredGroup);
+
+    _defineProperty(this, "deferredList", []);
+
+    if (arguments.length > 0) {
+      this.deferredList = this.deferredList.concat(arguments);
+    }
+  }
+
+  _createClass(DeferredGroup, [{
+    key: "create",
+    value: function create() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var deferred = new Deferred(name);
+      this.add(deferred);
+      return deferred;
+    }
+  }, {
+    key: "createResolver",
+    value: function createResolver() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      return this.create(name).resolve;
+    }
+  }, {
+    key: "add",
+    value: function add(deferred) {
+      this.deferredList.push(deferred);
+    }
+  }, {
+    key: "then",
+    value: function then(fn) {
+      return Promise.all(this.deferredList.map(function (d) {
+        return d.promise;
+      })).then(fn);
+    }
+  }]);
+
+  return DeferredGroup;
+}();
+
+exports.DeferredGroup = DeferredGroup;

package/Utils/Async/ObjectLock.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requestLock = void 0;
+
+var _Deferred = require("./Deferred");
+
+var deferredMap = new WeakMap();
+/**
+ * Creates a deferred lock on the given object in order to sync critical blocks with race conditions.
+ * Usage:
+ *  releaseLock = await requestLock(obj);
+ *  // do the critical actions in between
+ *  releaseLock(); // important: always call this at the end of the critical block
+ * Since it has to be used with the await keyword, it can guarantee that the block after the await requestLock(obj)
+ * will be executed only if the concurrent lock was released.
+ * @param object
+ * @return {Promise<function(): *>}
+ */
+
+var requestLock = function requestLock(object) {
+  var deferred = new _Deferred.Deferred();
+  var prev = deferredMap.get(object);
+  deferredMap.set(object, deferred);
+  return new Promise(function (resolve) {
+    if (prev) {
+      prev.then(function () {
+        resolve(deferred.resolve);
+      });
+    } else {
+      resolve(deferred.resolve);
+    }
+  });
+};
+
+exports.requestLock = requestLock;

package/Utils/Decorators/Observable.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.Observable = void 0;
+
+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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+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 Observable = /*#__PURE__*/function () {
+  function Observable(object) {
+    _classCallCheck(this, Observable);
+
+    _defineProperty(this, "_eventListeners", []);
+
+    _defineProperty(this, "_object", null);
+
+    this._object = object;
+    /*
+    , inject = ['on', 'off', 'dispatch']
+    if (inject && (inject instanceof Array)) {
+        for (let m of inject) {
+            object[m] = this[m].bind(this);
+        }
+    }
+    */
+  }
+
+  _createClass(Observable, [{
+    key: "on",
+    value: function on(eventName, callback) {
+      if (this.indexOf(eventName, callback) !== -1) {
+        // eslint-disable-next-line no-console
+        console.warn("The following callback is already added to the event: ".concat(eventName), callback);
+        return;
+      }
+
+      this._eventListeners.push({
+        eventName: eventName,
+        callback: callback
+      });
+    }
+  }, {
+    key: "off",
+    value: function off(eventName, callback) {
+      var idx = this.indexOf(eventName, callback);
+
+      if (idx !== -1) {
+        this._eventListeners.splice(idx, 1);
+      }
+    }
+  }, {
+    key: "indexOf",
+    value: function indexOf(eventName, callback) {
+      for (var o = 0; o < this._eventListeners.length; o++) {
+        var el = this._eventListeners[o];
+
+        if (el.eventName === eventName && el.callback === callback) {
+          return o;
+        }
+      }
+
+      return -1;
+    }
+  }, {
+    key: "dispatch",
+    value: function dispatch(eventName, params) {
+      var direct = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var notify = this.createNotifyFunction(eventName, params);
+
+      if (direct) {
+        notify();
+      } else {
+        setTimeout(notify);
+      }
+    }
+  }, {
+    key: "createNotifyFunction",
+    value: function createNotifyFunction(eventName, params) {
+      var _this = this;
+
+      return function () {
+        var _iterator = _createForOfIteratorHelper(_this._eventListeners),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var el = _step.value;
+
+            if (el.eventName === eventName) {
+              el.callback.call(_this._object, {
+                eventName: eventName,
+                time: new Date(),
+                data: params
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      };
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._eventListeners = [];
+      this._object = undefined;
+    }
+  }]);
+
+  return Observable;
+}();
+
+exports.Observable = Observable;
+var _default = Observable;
+exports["default"] = _default;

package/Utils/Dev/HOCs/withFilePicker.js

@@ -0,0 +1,101 @@
+"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.withFilePicker = withFilePicker;
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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; }
+
+/**
+ * HOC to provide src to the wrapped component with a file input field in a really simple way.
+ * Note: this component was created only as a development helper
+ * @param Component
+ * @returns {FilePicker}
+ */
+function withFilePicker(Component) {
+  var FilePicker = /*#__PURE__*/function (_React$Component) {
+    _inherits(FilePicker, _React$Component);
+
+    var _super = _createSuper(FilePicker);
+
+    function FilePicker() {
+      var _this;
+
+      _classCallCheck(this, FilePicker);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        src: false
+      });
+
+      _defineProperty(_assertThisInitialized(_this), "onChange", function (evt) {
+        var reader = new FileReader();
+        reader.addEventListener('load', function () {
+          return _this.setState({
+            src: reader.result
+          });
+        }, false);
+
+        if (evt.target.files && evt.target.files.length) {
+          reader.readAsDataURL(evt.target.files[0]);
+        }
+      });
+
+      return _this;
+    }
+
+    _createClass(FilePicker, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement("input", {
+          type: "file",
+          onChange: this.onChange
+        }), /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(Component, _extends({
+          src: this.state.src
+        }, this.props))));
+      }
+    }]);
+
+    return FilePicker;
+  }(_react["default"].Component);
+
+  return FilePicker;
+}
+
+var _default = withFilePicker;
+exports["default"] = _default;

package/Utils/Dev/isDev.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isDev;
+
+/**
+ * Returns if the environment is development or not
+ * When true it calls the given callback if there is one
+ * @param {function} [cb]
+ * @returns {boolean}
+ */
+function isDev(cb) {
+  if (process.env.NODE_ENV !== 'production') {
+    cb && cb();
+    return true;
+  }
+
+  return false;
+}

package/Utils/Events/pointerEvent.js

@@ -0,0 +1,199 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPointerEventListener = exports.createPointerHitListener = exports.createPositionChangeChecker = exports.getPointFromPointerEvent = void 0;
+
+/**
+ * @param {MouseEvent|TouchEvent} evt
+ * @param {HTMLElement} relativeTo
+ * @returns {{x: number, y: number}}
+ */
+var getPointFromPointerEvent = function getPointFromPointerEvent(evt, relativeTo) {
+  var x, y;
+  var touches = evt.changedTouches && evt.changedTouches.length > 0 && evt.changedTouches || evt.touches;
+
+  if (touches && touches.length > 0) {
+    x = touches[0].clientX;
+    y = touches[0].clientY;
+  } else {
+    x = evt.clientX;
+    y = evt.clientY;
+  }
+
+  if (relativeTo) {
+    var _relativeTo$getBoundi = relativeTo.getBoundingClientRect(),
+        top = _relativeTo$getBoundi.top,
+        left = _relativeTo$getBoundi.left;
+
+    x -= left;
+    y -= top;
+  }
+
+  return {
+    x: x,
+    y: y
+  };
+};
+/**
+ * Creates and stores the print of the event position for later comparison.
+ * It can be used to create a position change checker function, in order to solve the problem
+ * of Chrome's automatically triggered mousemove event when clicking without moving the mouse.
+ * @param evt
+ * @returns {function(*=): boolean}
+ */
+
+
+exports.getPointFromPointerEvent = getPointFromPointerEvent;
+
+var createPositionChangeChecker = function createPositionChangeChecker(evt) {
+  var getPositionPrint = function getPositionPrint(evt) {
+    return '' + evt.pageX + '-' + evt.pageY;
+  };
+
+  var initialPrint = getPositionPrint(evt);
+  return function (evt) {
+    return initialPrint !== getPositionPrint(evt);
+  };
+};
+/**
+ * Creates a "hit" event listener.
+ * It detects a single tap (or click) - if the pointer was released without moving.
+ * @param element
+ * @param {function} fn The event handler function
+ * @returns {function()} A function to be called to remove the event listeners
+ */
+
+
+exports.createPositionChangeChecker = createPositionChangeChecker;
+
+var createPointerHitListener = function createPointerHitListener(element, fn) {
+  var moved = false;
+  var checkPositionChange = false; // preventing the emulated mouse events after touchend
+  // see https://developer.mozilla.org/en-US/docs/Web/API/Touch_events/Supporting_both_TouchEvent_and_MouseEvent
+
+  var preventEmulatedEvents = function preventEmulatedEvents(cb) {
+    return function (evt) {
+      if (!moved && evt.type === 'touchend') {
+        evt.preventDefault();
+      }
+
+      cb(evt);
+    };
+  };
+
+  var startHandler = function startHandler(evt) {
+    moved = false;
+    var isTouch = (evt.changedTouches || evt.touches || []).length > 0;
+
+    if (isTouch) {
+      // in case of touch events we can skip the check, the events are fired correctly
+      checkPositionChange = false;
+      element.addEventListener('touchmove', moveHandler, true);
+      element.addEventListener('touchend', endHandler);
+    } else {
+      checkPositionChange = createPositionChangeChecker(evt);
+      element.addEventListener('mousemove', moveHandler);
+      element.addEventListener('mouseup', endHandler);
+    }
+  };
+
+  var moveHandler = function moveHandler(evt) {
+    if (checkPositionChange) {
+      moved = checkPositionChange(evt);
+    } else {
+      moved = true;
+    }
+  };
+
+  var endHandler = preventEmulatedEvents(function () {
+    !moved && fn.apply(void 0, arguments);
+    element.removeEventListener('touchmove', moveHandler, true);
+    element.removeEventListener('mousemove', moveHandler);
+    element.removeEventListener('touchend', endHandler);
+    element.removeEventListener('mouseup', endHandler);
+  });
+  element.addEventListener('mousedown', startHandler);
+  element.addEventListener('touchstart', startHandler);
+  return function () {
+    element.removeEventListener('mousedown', startHandler);
+    element.removeEventListener('touchstart', startHandler);
+  };
+};
+/**
+ * Creates a general pointer event listener (for mouse and touch events)
+ * @param element
+ * @param {string} name The name of the event phase ('start'|'move'|'end')
+ * @param {function} fn The event handler function
+ * @returns {function()} A function to be called to remove the event listeners
+ */
+
+
+exports.createPointerHitListener = createPointerHitListener;
+
+var createPointerEventListener = function createPointerEventListener(element, name, fn) {
+  var touchName, mouseName;
+
+  switch (name) {
+    case 'start':
+      {
+        touchName = 'touchstart';
+        mouseName = 'mousedown';
+        break;
+      }
+
+    case 'move':
+      {
+        touchName = 'touchmove';
+        mouseName = 'mousemove';
+        break;
+      }
+
+    case 'end':
+      {
+        touchName = 'touchend';
+        mouseName = 'mouseup';
+        break;
+      }
+  }
+
+  var tolerance = 1; // ms
+
+  var timeStamp = 0;
+
+  var touchHandler = function touchHandler(evt) {
+    // prevent mouse events if it's a touch event
+    //evt.type.indexOf('touch') === 0 && evt.preventDefault();
+    timeStamp = evt.timeStamp;
+
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    fn.apply(void 0, [evt].concat(args));
+  };
+
+  var mouseHandler = function mouseHandler(evt) {
+    if (evt.timeStamp - timeStamp < tolerance) {
+      // eslint-disable-next-line no-console
+      console.log('Skipped double event handling.');
+      return;
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+
+    fn.apply(void 0, [evt].concat(args));
+  };
+
+  element.addEventListener(touchName, touchHandler);
+  element.addEventListener(mouseName, mouseHandler);
+  return function () {
+    element.removeEventListener(touchName, touchHandler);
+    element.removeEventListener(mouseName, mouseHandler);
+  };
+};
+
+exports.createPointerEventListener = createPointerEventListener;

package/Utils/Events/preventEventDoubling.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.preventEventDoubling = void 0;
+
+var preventEventDoubling = function preventEventDoubling(eventHandler) {
+  var minTimeDiff = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  var lastClickTime;
+  return function () {
+    var thisClickTime = new Date().getTime();
+
+    if (lastClickTime && thisClickTime - lastClickTime < minTimeDiff) {
+      return;
+    }
+
+    lastClickTime = thisClickTime;
+    return eventHandler.apply(void 0, arguments);
+  };
+};
+
+exports.preventEventDoubling = preventEventDoubling;