kitchen-simulator 1.1.1-test.49 → 1.1.1-test.50

package/lib/utils/name-generator.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var NameGenerator = exports["default"] = /*#__PURE__*/function () {
+  function NameGenerator() {
+    _classCallCheck(this, NameGenerator);
+  }
+  return _createClass(NameGenerator, null, [{
+    key: "generateName",
+    value: function generateName(prototype, type) {
+      return type.substr(0, 1).toUpperCase() + type.substr(1);
+    }
+  }]);
+}();

package/lib/utils/objects-utils.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllMeshes = getAllMeshes;
+exports.objectsCompare = objectsCompare;
+exports.objectsMap = objectsMap;
+exports.vectorIntersectWithMesh = vectorIntersectWithMesh;
+var Three = _interopRequireWildcard(require("three"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+String.prototype.isLeftPlaceholder = function () {
+  return this.match(/_L$|_L_\d$/) != null;
+};
+String.prototype.isRightPlaceholder = function () {
+  return this.match(/_R$|_R_\d$/) != null;
+};
+function objectsMap(object, func) {
+  var mappedObject = {};
+  for (var key in object) {
+    mappedObject[key] = func(key, mappedObject[key]);
+  }
+  return mappedObject;
+}
+function objectsCompare(x, y) {
+  if (x === y) return true;
+  if (!(x instanceof Object) || !(y instanceof Object)) return false;
+  if (x.constructor !== y.constructor) return false;
+  for (var p in x) {
+    if (!x.hasOwnProperty(p)) continue;
+    if (!y.hasOwnProperty(p)) return false;
+    if (x[p] === y[p]) continue;
+    if (_typeof(x[p]) !== 'object') return false;
+    if (!objectsCompare(x[p], y[p])) return false;
+  }
+  for (var _p in y) {
+    if (y.hasOwnProperty(_p) && !x.hasOwnProperty(_p)) return false;
+  }
+  return true;
+}
+function getAllMeshes(objects) {
+  var meshes = [];
+  objects.forEach(function (object) {
+    if (!object) return;
+    object.traverse(function (o) {
+      if (o.isMesh && o.geometry) {
+        meshes.push(o);
+      }
+    });
+  });
+  return meshes;
+}
+function vectorIntersectWithMesh(origin, target) {
+  var vectorDir = new Three.Vector3(origin.x, origin.y - 1000, origin.z);
+  var ray = new Three.Raycaster();
+  ray.set(origin, vectorDir);
+  var intersects = ray.intersectObject(target, true);
+  return intersects.length > 0;
+}

package/lib/utils/phone-validator.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.phoneValidation = void 0;
+var phoneValidation = exports.phoneValidation = function phoneValidation(phone) {
+  var result = /^(\+1\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}$/;
+  return result.test(String(phone).toLowerCase());
+};

package/lib/utils/process-black-list.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCurrentCabinetObject = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var buildCurrentCabinetObject = exports.buildCurrentCabinetObject = function buildCurrentCabinetObject(cabinet, texture) {
+  return {
+    type: cabinet.name,
+    // e.g. "B09"
+    name: cabinet.name,
+    category: cabinet.type,
+    // "cabinet"
+    doorStyle: _objectSpread({}, texture),
+    itemID: cabinet.itemID,
+    sku_number: cabinet.name
+  };
+};

package/lib/utils/react-if.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = If;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @return {null}
+ */
+function If(_ref) {
+  var condition = _ref.condition,
+    style = _ref.style,
+    children = _ref.children;
+  return condition ? Array.isArray(children) ? /*#__PURE__*/_react["default"].createElement("div", {
+    style: style
+  }, children) : children : null;
+}
+If.propTypes = {
+  condition: _propTypes["default"].bool.isRequired,
+  style: _propTypes["default"].object
+};

package/lib/utils/snap-scene.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sceneSnapElements = sceneSnapElements;
+var _snap = require("./snap");
+var _export = require("./export");
+var _immutable = require("immutable");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function sceneSnapElements(scene) {
+  var snapElements = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _immutable.List();
+  var snapMask = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new _immutable.Map();
+  var width = scene.width,
+    height = scene.height;
+  var a, b, c;
+  return snapElements.withMutations(function (snapElements) {
+    scene.layers.forEach(function (layer) {
+      var lines = layer.lines,
+        vertices = layer.vertices;
+      vertices.forEach(function (_ref) {
+        var vertexID = _ref.id,
+          x = _ref.x,
+          y = _ref.y;
+        if (snapMask.get(_snap.SNAP_POINT)) {
+          (0, _snap.addPointSnap)(snapElements, x, y, 10, 10, vertexID);
+        }
+        if (snapMask.get(_snap.SNAP_LINE)) {
+          var _GeometryUtils$horizo = _export.GeometryUtils.horizontalLine(y);
+          a = _GeometryUtils$horizo.a;
+          b = _GeometryUtils$horizo.b;
+          c = _GeometryUtils$horizo.c;
+          (0, _snap.addLineSnap)(snapElements, a, b, c, 10, 1, vertexID);
+          var _GeometryUtils$vertic = _export.GeometryUtils.verticalLine(x);
+          a = _GeometryUtils$vertic.a;
+          b = _GeometryUtils$vertic.b;
+          c = _GeometryUtils$vertic.c;
+          (0, _snap.addLineSnap)(snapElements, a, b, c, 10, 1, vertexID);
+          var _GeometryUtils$upcros = _export.GeometryUtils.upcrossLine(x, y);
+          a = _GeometryUtils$upcros.a;
+          b = _GeometryUtils$upcros.b;
+          c = _GeometryUtils$upcros.c;
+          (0, _snap.addLineSnap)(snapElements, a, b, c, 10, 3, null);
+          var _GeometryUtils$downcr = _export.GeometryUtils.downcrossLine(x, y);
+          a = _GeometryUtils$downcr.a;
+          b = _GeometryUtils$downcr.b;
+          c = _GeometryUtils$downcr.c;
+          (0, _snap.addLineSnap)(snapElements, a, b, c, 10, 3, null);
+        }
+      });
+      if (snapMask.get(_snap.SNAP_SEGMENT)) {
+        lines.forEach(function (_ref2) {
+          var lineID = _ref2.id,
+            _ref2$vertices = _slicedToArray(_ref2.vertices, 2),
+            v0 = _ref2$vertices[0],
+            v1 = _ref2$vertices[1];
+          var _vertices$get = vertices.get(v0),
+            x1 = _vertices$get.x,
+            y1 = _vertices$get.y;
+          var _vertices$get2 = vertices.get(v1),
+            x2 = _vertices$get2.x,
+            y2 = _vertices$get2.y;
+          (0, _snap.addLineSegmentSnap)(snapElements, x1, y1, x2, y2, 20, 1, lineID);
+        });
+      }
+    });
+    if (snapMask.get(_snap.SNAP_GRID)) {
+      var divider = 5;
+      var gridCellSize = 100 / divider;
+      var xCycle = width / gridCellSize;
+      var yCycle = height / gridCellSize;
+      for (var x = 0; x < xCycle; x++) {
+        var xMul = x * gridCellSize;
+        for (var y = 0; y < yCycle; y++) {
+          var yMul = y * gridCellSize;
+          var onXCross = !(x % divider) ? true : false;
+          var onYCross = !(y % divider) ? true : false;
+          (0, _snap.addGridSnap)(snapElements, xMul, yMul, 10, onXCross && onYCross ? 15 : 10, null);
+        }
+      }
+    }
+    if (snapMask.get(_snap.SNAP_GUIDE)) {
+      var horizontal = scene.getIn(['guides', 'horizontal']);
+      var vertical = scene.getIn(['guides', 'vertical']);
+      var hValues = horizontal.valueSeq();
+      var vValues = vertical.valueSeq();
+      hValues.forEach(function (hVal) {
+        vValues.forEach(function (vVal) {
+          (0, _snap.addPointSnap)(snapElements, vVal, hVal, 10, 10);
+        });
+      });
+      hValues.forEach(function (hVal) {
+        return (0, _snap.addLineSegmentSnap)(snapElements, 0, hVal, width, hVal, 20, 1);
+      });
+      vValues.forEach(function (vVal) {
+        return (0, _snap.addLineSegmentSnap)(snapElements, vVal, 0, vVal, height, 20, 1);
+      });
+    }
+  });
+}

package/lib/utils/snap.js

@@ -0,0 +1,249 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SNAP_SEGMENT = exports.SNAP_POINT = exports.SNAP_MASK = exports.SNAP_LINE = exports.SNAP_GUIDE = exports.SNAP_GRID = void 0;
+exports.addGridSnap = addGridSnap;
+exports.addLineSegmentSnap = addLineSegmentSnap;
+exports.addLineSnap = addLineSnap;
+exports.addPointSnap = addPointSnap;
+exports.nearestSnap = nearestSnap;
+var _immutable = require("immutable");
+var Geometry = _interopRequireWildcard(require("./geometry"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var SNAP_POINT = exports.SNAP_POINT = 'SNAP_POINT';
+var SNAP_LINE = exports.SNAP_LINE = 'SNAP_LINE';
+var SNAP_SEGMENT = exports.SNAP_SEGMENT = 'SNAP_SEGMENT';
+var SNAP_GRID = exports.SNAP_GRID = 'SNAP_GRID';
+var SNAP_GUIDE = exports.SNAP_GUIDE = 'SNAP_GUIDE';
+var SNAP_MASK = exports.SNAP_MASK = new _immutable.Map({
+  SNAP_POINT: true,
+  SNAP_LINE: true,
+  SNAP_SEGMENT: true,
+  SNAP_GRID: false,
+  SNAP_GUIDE: true
+});
+var PointSnap = /*#__PURE__*/function (_Record) {
+  function PointSnap() {
+    _classCallCheck(this, PointSnap);
+    return _callSuper(this, PointSnap, arguments);
+  }
+  _inherits(PointSnap, _Record);
+  return _createClass(PointSnap, [{
+    key: "nearestPoint",
+    value: function nearestPoint(x, y) {
+      return {
+        x: this.x,
+        y: this.y,
+        distance: Geometry.pointsDistance(this.x, this.y, x, y)
+      };
+    }
+  }, {
+    key: "isNear",
+    value: function isNear(x, y, distance) {
+      return ~(this.x - x) + 1 < distance && ~(this.y - y) + 1 < distance;
+    }
+  }]);
+}((0, _immutable.Record)({
+  type: 'point',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new _immutable.List()
+}));
+var LineSnap = /*#__PURE__*/function (_Record2) {
+  function LineSnap() {
+    _classCallCheck(this, LineSnap);
+    return _callSuper(this, LineSnap, arguments);
+  }
+  _inherits(LineSnap, _Record2);
+  return _createClass(LineSnap, [{
+    key: "nearestPoint",
+    value: function nearestPoint(x, y) {
+      return _objectSpread(_objectSpread({}, Geometry.closestPointFromLine(this.a, this.b, this.c, x, y)), {}, {
+        distance: Geometry.distancePointFromLine(this.a, this.b, this.c, x, y)
+      });
+    }
+  }, {
+    key: "isNear",
+    value: function isNear(x, y, distance) {
+      return true;
+    }
+  }]);
+}((0, _immutable.Record)({
+  type: 'line',
+  a: -1,
+  b: -1,
+  c: -1,
+  radius: 1,
+  priority: 1,
+  related: new _immutable.List()
+}));
+var LineSegmentSnap = /*#__PURE__*/function (_Record3) {
+  function LineSegmentSnap() {
+    _classCallCheck(this, LineSegmentSnap);
+    return _callSuper(this, LineSegmentSnap, arguments);
+  }
+  _inherits(LineSegmentSnap, _Record3);
+  return _createClass(LineSegmentSnap, [{
+    key: "nearestPoint",
+    value: function nearestPoint(x, y) {
+      return _objectSpread(_objectSpread({}, Geometry.closestPointFromLineSegment(this.x1, this.y1, this.x2, this.y2, x, y)), {}, {
+        distance: Geometry.distancePointFromLineSegment({
+          x: this.x1,
+          y: this.y1
+        }, {
+          x: this.x2,
+          y: this.y2
+        }, x, y)
+      });
+    }
+  }, {
+    key: "isNear",
+    value: function isNear(x, y, distance) {
+      return true;
+    }
+  }]);
+}((0, _immutable.Record)({
+  type: 'line-segment',
+  x1: -1,
+  y1: -1,
+  x2: -1,
+  y2: -1,
+  radius: 1,
+  priority: 1,
+  related: new _immutable.List()
+}));
+var GridSnap = /*#__PURE__*/function (_Record4) {
+  function GridSnap() {
+    _classCallCheck(this, GridSnap);
+    return _callSuper(this, GridSnap, arguments);
+  }
+  _inherits(GridSnap, _Record4);
+  return _createClass(GridSnap, [{
+    key: "nearestPoint",
+    value: function nearestPoint(x, y) {
+      return {
+        x: this.x,
+        y: this.y,
+        distance: Geometry.pointsDistance(this.x, this.y, x, y)
+      };
+    }
+  }, {
+    key: "isNear",
+    value: function isNear(x, y, distance) {
+      return ~(this.x - x) + 1 < distance && ~(this.y - y) + 1 < distance;
+    }
+  }]);
+}((0, _immutable.Record)({
+  type: 'grid',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new _immutable.List()
+}));
+function nearestSnap(snapElements, x, y, snapMask) {
+  var filter = {
+    point: snapMask.get(SNAP_POINT),
+    line: snapMask.get(SNAP_LINE),
+    'line-segment': snapMask.get(SNAP_SEGMENT),
+    grid: snapMask.get(SNAP_GRID)
+  };
+  return snapElements.valueSeq().filter(function (el) {
+    return filter[el.type] && el.isNear(x, y, el.radius);
+  }).map(function (snap) {
+    return {
+      snap: snap,
+      point: snap.nearestPoint(x, y)
+    };
+  }).filter(function (_ref) {
+    var radius = _ref.snap.radius,
+      distance = _ref.point.distance;
+    return distance < radius;
+  }).min(function (_ref2, _ref3) {
+    var p1 = _ref2.snap.priority,
+      d1 = _ref2.point.distance;
+    var p2 = _ref3.snap.priority,
+      d2 = _ref3.point.distance;
+    return p1 === p2 ? d1 < d2 ? -1 : 1 : p1 > p2 ? -1 : 1;
+  });
+}
+function addPointSnap(snapElements, x, y, radius, priority, related) {
+  related = new _immutable.List([related]);
+  return snapElements.push(new PointSnap({
+    x: x,
+    y: y,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}
+function addLineSnap(snapElements, a, b, c, radius, priority, related) {
+  related = new _immutable.List([related]);
+  return snapElements.withMutations(function (snapElements) {
+    var alreadyPresent = snapElements.some(function (lineSnap) {
+      return lineSnap.type === 'line' && a === lineSnap.a && b === lineSnap.b && c === lineSnap.c;
+    });
+    if (alreadyPresent) return snapElements;
+    var intersections = snapElements.valueSeq().filter(function (snap) {
+      return snap.type === 'line';
+    }).map(function (snap) {
+      return Geometry.twoLinesIntersection(snap.a, snap.b, snap.c, a, b, c);
+    }).filter(function (intersection) {
+      return intersection !== undefined;
+    }).forEach(function (_ref4) {
+      var x = _ref4.x,
+        y = _ref4.y;
+      return addPointSnap(snapElements, x, y, 20, 40);
+    });
+    snapElements.push(new LineSnap({
+      a: a,
+      b: b,
+      c: c,
+      radius: radius,
+      priority: priority,
+      related: related
+    }));
+  });
+}
+function addLineSegmentSnap(snapElements, x1, y1, x2, y2, radius, priority, related) {
+  related = new _immutable.List([related]);
+  return snapElements.push(new LineSegmentSnap({
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}
+function addGridSnap(snapElements, x, y, radius, priority, related) {
+  related = new _immutable.List([related]);
+  return snapElements.push(new GridSnap({
+    x: x,
+    y: y,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}

package/lib/utils/summarizeCart.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.summarizeItems = summarizeItems;
+function summarizeItems(items) {
+  var totalCount = 0;
+  var totalPrice = 0;
+  var totalRegularPrice = 0;
+  for (var sku in items) {
+    var item = items[sku];
+    var _ref = item || {},
+      _ref$count = _ref.count,
+      count = _ref$count === void 0 ? 0 : _ref$count,
+      _ref$regularPrice = _ref.regularPrice,
+      regularPrice = _ref$regularPrice === void 0 ? 0 : _ref$regularPrice,
+      disCountPrice = _ref.disCountPrice;
+    var priceToUse = typeof disCountPrice === 'number' && !isNaN(disCountPrice) ? disCountPrice : regularPrice;
+    totalCount += count;
+    totalPrice += count * priceToUse;
+    totalRegularPrice += count * regularPrice;
+  }
+  return {
+    totalCount: totalCount,
+    totalRegularPrice: totalRegularPrice,
+    totalPrice: totalPrice,
+    totalSavings: totalRegularPrice - totalPrice
+  };
+}