kitchen-simulator 2.0.0 → 2.0.1-dot-color

package/lib/utils/name-generator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var NameGenerator = exports["default"] = /*#__PURE__*/function () {
+  function NameGenerator() {
+    (0, _classCallCheck2["default"])(this, NameGenerator);
+  }
+  return (0, _createClass2["default"])(NameGenerator, null, [{
+    key: "generateName",
+    value: function generateName(prototype, type) {
+      return type.substr(0, 1).toUpperCase() + type.substr(1);
+    }
+  }]);
+}();
+module.exports = exports.default;

package/lib/utils/objects-utils.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllMeshes = getAllMeshes;
+exports.objectsCompare = objectsCompare;
+exports.objectsMap = objectsMap;
+exports.vectorIntersectWithMesh = vectorIntersectWithMesh;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+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" != _typeof3(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); }
+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 ((0, _typeof2["default"])(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,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCurrentCabinetObject = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/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) { (0, _defineProperty2["default"])(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; }
+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,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = If;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+/**
+ * @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
+};
+module.exports = exports.default;

package/lib/utils/snap-scene.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sceneSnapElements = sceneSnapElements;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _snap = require("./snap");
+var _export = require("./export");
+var _immutable = require("immutable");
+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 = (0, _slicedToArray2["default"])(_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,245 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+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) { (0, _defineProperty2["default"])(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 = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); }
+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() {
+    (0, _classCallCheck2["default"])(this, PointSnap);
+    return _callSuper(this, PointSnap, arguments);
+  }
+  (0, _inherits2["default"])(PointSnap, _Record);
+  return (0, _createClass2["default"])(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() {
+    (0, _classCallCheck2["default"])(this, LineSnap);
+    return _callSuper(this, LineSnap, arguments);
+  }
+  (0, _inherits2["default"])(LineSnap, _Record2);
+  return (0, _createClass2["default"])(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() {
+    (0, _classCallCheck2["default"])(this, LineSegmentSnap);
+    return _callSuper(this, LineSegmentSnap, arguments);
+  }
+  (0, _inherits2["default"])(LineSegmentSnap, _Record3);
+  return (0, _createClass2["default"])(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() {
+    (0, _classCallCheck2["default"])(this, GridSnap);
+    return _callSuper(this, GridSnap, arguments);
+  }
+  (0, _inherits2["default"])(GridSnap, _Record4);
+  return (0, _createClass2["default"])(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
+  };
+}