kitchen-simulator 5.10.2-react.18 → 5.10.4-react.18

package/es/utils/name-generator.js

@@ -0,0 +1,17 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var NameGenerator = /*#__PURE__*/function () {
+  function NameGenerator() {
+    _classCallCheck(this, NameGenerator);
+  }
+  return _createClass(NameGenerator, null, [{
+    key: "generateName",
+    value: function generateName(prototype, type) {
+      if (!prototype || !type) {
+        return null;
+      }
+      return type.substr(0, 1).toUpperCase() + type.substr(1);
+    }
+  }]);
+}();
+export { NameGenerator as default };

package/es/utils/objects-utils.js

@@ -0,0 +1,50 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import * as Three from 'three';
+String.prototype.isLeftPlaceholder = function () {
+  return this.match(/_L$|_L_\d$/) != null;
+};
+String.prototype.isRightPlaceholder = function () {
+  return this.match(/_R$|_R_\d$/) != null;
+};
+export function objectsMap(object, func) {
+  var mappedObject = {};
+  for (var key in object) {
+    mappedObject[key] = func(key, mappedObject[key]);
+  }
+  return mappedObject;
+}
+export 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;
+}
+export 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;
+}
+export 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/es/utils/phone-validator.js

@@ -0,0 +1,4 @@
+export var phoneValidation = function phoneValidation(phone) {
+  var result = /^(\+1\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}$/;
+  return result.test(String(phone).toLowerCase());
+};

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

@@ -0,0 +1,15 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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; }
+export var 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/es/utils/react-if.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+/**
+ * @return {null}
+ */
+export default function If(_ref) {
+  var condition = _ref.condition,
+    style = _ref.style,
+    children = _ref.children;
+  return condition ? Array.isArray(children) ? /*#__PURE__*/React.createElement("div", {
+    style: style
+  }, children) : children : null;
+}
+If.propTypes = {
+  condition: PropTypes.bool.isRequired,
+  style: PropTypes.object
+};

package/es/utils/ruler.js

@@ -0,0 +1,58 @@
+import { convert } from "../utils/convert-units-lite.js";
+import { UNIT_CENTIMETER, UNIT_INCH, UNIT_MILLIMETER } from "../constants";
+
+// Below this length, the measurement LINE is hidden
+var MIN_LENGTH_TO_SHOW_RULER_LINE_INCH = 13;
+
+// Below this length, the measurement VALUE (text) is hidden
+var MIN_LENGTH_TO_SHOW_RULER_VALUE_INCH = 3;
+function formatDistance(value, fixed) {
+  // format with fixed decimals first
+  var text = value.toFixed(fixed);
+
+  // remove trailing zeros AFTER decimal, then remove trailing dot if needed
+  // examples:
+  // 2.00 -> 2
+  // 2.50 -> 2.5
+  // 200.00 -> 200
+  text = text.replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '');
+  return text;
+}
+function getUnitString(unit) {
+  if (unit === 'cm' || unit === 'mm') return '';
+  if (unit === 'in') return '"';
+  return unit;
+}
+export function getRulerDisplayData(_ref) {
+  var length = _ref.length,
+    unit = _ref.unit,
+    rulerUnit = _ref.rulerUnit,
+    layerUnit = _ref.layerUnit,
+    _ref$charWidth = _ref.charWidth,
+    charWidth = _ref$charWidth === void 0 ? 8 : _ref$charWidth;
+  // 7.62 cm -> ruLength 2.99 in
+  var ruLength = convert(length).from(unit).to(rulerUnit);
+  var fixedLength = layerUnit === UNIT_INCH ? 0 : layerUnit === UNIT_MILLIMETER ? 0 : layerUnit === UNIT_CENTIMETER ? 1 : 2;
+
+  // 2.99 in -> valueInLayerUnit 2.99 in
+  var valueInLayerUnit = convert(ruLength).from(rulerUnit).to(layerUnit);
+
+  // 2.99 -> "3"
+  var distanceText = formatDistance(valueInLayerUnit, fixedLength);
+  var unitStr = getUnitString(layerUnit);
+  var textCount = distanceText.length + unitStr.length;
+  // textLength = (3 + ") * 8 = 16
+  var textLength = textCount * charWidth;
+
+  // lengthInInch = 7.62 cm -> 2.99 inch
+  var lengthInInch = convert(length).from(unit).to(UNIT_INCH);
+  var bShowText = lengthInInch > MIN_LENGTH_TO_SHOW_RULER_VALUE_INCH && length - textLength + 24 > 0;
+  var bShowLine = lengthInInch > MIN_LENGTH_TO_SHOW_RULER_LINE_INCH && length - textLength - 8 > 0;
+  return {
+    distanceText: distanceText,
+    unitStr: unitStr,
+    textLength: textLength,
+    bShowText: bShowText,
+    bShowLine: bShowLine
+  };
+}

package/es/utils/snap-scene.js

@@ -0,0 +1,94 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { SNAP_POINT, SNAP_LINE, SNAP_SEGMENT, SNAP_GRID, SNAP_GUIDE, addPointSnap, addLineSnap, addLineSegmentSnap, addGridSnap } from "./snap";
+import { GeometryUtils } from "./export";
+import { Map, List } from 'immutable';
+export function sceneSnapElements(scene) {
+  var snapElements = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new List();
+  var snapMask = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new 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_POINT)) {
+          addPointSnap(snapElements, x, y, 10, 10, vertexID);
+        }
+        if (snapMask.get(SNAP_LINE)) {
+          var _GeometryUtils$horizo = GeometryUtils.horizontalLine(y);
+          a = _GeometryUtils$horizo.a;
+          b = _GeometryUtils$horizo.b;
+          c = _GeometryUtils$horizo.c;
+          addLineSnap(snapElements, a, b, c, 10, 1, vertexID);
+          var _GeometryUtils$vertic = GeometryUtils.verticalLine(x);
+          a = _GeometryUtils$vertic.a;
+          b = _GeometryUtils$vertic.b;
+          c = _GeometryUtils$vertic.c;
+          addLineSnap(snapElements, a, b, c, 10, 1, vertexID);
+          var _GeometryUtils$upcros = GeometryUtils.upcrossLine(x, y);
+          a = _GeometryUtils$upcros.a;
+          b = _GeometryUtils$upcros.b;
+          c = _GeometryUtils$upcros.c;
+          addLineSnap(snapElements, a, b, c, 10, 3, null);
+          var _GeometryUtils$downcr = GeometryUtils.downcrossLine(x, y);
+          a = _GeometryUtils$downcr.a;
+          b = _GeometryUtils$downcr.b;
+          c = _GeometryUtils$downcr.c;
+          addLineSnap(snapElements, a, b, c, 10, 3, null);
+        }
+      });
+      if (snapMask.get(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;
+          addLineSegmentSnap(snapElements, x1, y1, x2, y2, 20, 1, lineID);
+        });
+      }
+    });
+    if (snapMask.get(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;
+          addGridSnap(snapElements, xMul, yMul, 10, onXCross && onYCross ? 15 : 10, null);
+        }
+      }
+    }
+    if (snapMask.get(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) {
+          addPointSnap(snapElements, vVal, hVal, 10, 10);
+        });
+      });
+      hValues.forEach(function (hVal) {
+        return addLineSegmentSnap(snapElements, 0, hVal, width, hVal, 20, 1);
+      });
+      vValues.forEach(function (vVal) {
+        return addLineSegmentSnap(snapElements, vVal, 0, vVal, height, 20, 1);
+      });
+    }
+  });
+}

package/es/utils/snap.js

@@ -0,0 +1,231 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+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 _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { Map, List, Record } from 'immutable';
+import * as Geometry from "./geometry";
+export var SNAP_POINT = 'SNAP_POINT';
+export var SNAP_LINE = 'SNAP_LINE';
+export var SNAP_SEGMENT = 'SNAP_SEGMENT';
+export var SNAP_GRID = 'SNAP_GRID';
+export var SNAP_GUIDE = 'SNAP_GUIDE';
+export var SNAP_MASK = new 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;
+    }
+  }]);
+}(Record({
+  type: 'point',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new 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;
+    }
+  }]);
+}(Record({
+  type: 'line',
+  a: -1,
+  b: -1,
+  c: -1,
+  radius: 1,
+  priority: 1,
+  related: new 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;
+    }
+  }]);
+}(Record({
+  type: 'line-segment',
+  x1: -1,
+  y1: -1,
+  x2: -1,
+  y2: -1,
+  radius: 1,
+  priority: 1,
+  related: new 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;
+    }
+  }]);
+}(Record({
+  type: 'grid',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new List()
+}));
+export 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;
+  });
+}
+export function addPointSnap(snapElements, x, y, radius, priority, related) {
+  related = new List([related]);
+  return snapElements.push(new PointSnap({
+    x: x,
+    y: y,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}
+export function addLineSnap(snapElements, a, b, c, radius, priority, related) {
+  related = new 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
+    }));
+  });
+}
+export function addLineSegmentSnap(snapElements, x1, y1, x2, y2, radius, priority, related) {
+  related = new List([related]);
+  return snapElements.push(new LineSegmentSnap({
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}
+export function addGridSnap(snapElements, x, y, radius, priority, related) {
+  related = new List([related]);
+  return snapElements.push(new GridSnap({
+    x: x,
+    y: y,
+    radius: radius,
+    priority: priority,
+    related: related
+  }));
+}

package/es/utils/summarizeCart.js

@@ -0,0 +1,24 @@
+export 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
+  };
+}