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

package/es/class/project.js

@@ -0,0 +1,937 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+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; }
+import { Map, List } from 'immutable';
+import { MODE_VIEWING_CATALOG, MODE_CONFIGURING_PROJECT, MODE_IDLE, MODE_DRAWING_ITEM_3D, MODE_3D_VIEW, MODE_DRAGGING_ITEM_3D, MODE_IDLE_3D, MODE_ROTATING_ITEM_3D, MODE_DRAWING_ITEM, MODE_DRAWING_LINE, MODE_WAITING_DRAWING_LINE, MODE_DRAWING_HOLE, ARRAY_3D_MODES, END_DRAWING_LINE } from "../constants";
+import * as constants from "../constants";
+import { State, Catalog, Scene, safeLoadMapList, CatalogElement } from "../models";
+import { GeometryUtils, history } from "../utils/export";
+import { Layer, Group, Line, Hole, Item, Area, HorizontalGuide, VerticalGuide } from "../class/export";
+import * as viewer2DActions from "../actions/viewer2d-actions";
+import { centering2D, isEmpty } from "../utils/helper";
+import { convert } from "../utils/convert-units-lite";
+var Project = /*#__PURE__*/function () {
+  function Project() {
+    _classCallCheck(this, Project);
+  }
+  return _createClass(Project, null, [{
+    key: "setAlterate",
+    value: function setAlterate(state) {
+      return {
+        updatedState: state.set('alterate', !state.alterate)
+      };
+    }
+  }, {
+    key: "openCatalog",
+    value: function openCatalog(state) {
+      state = this.setMode(state, MODE_VIEWING_CATALOG).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "newProject",
+    value: function newProject(state) {
+      var _state$toJS$doorStyle, _state;
+      var doorStyle = (_state$toJS$doorStyle = (_state = state) === null || _state === void 0 || (_state = _state.toJS()) === null || _state === void 0 ? void 0 : _state.doorStyle) !== null && _state$toJS$doorStyle !== void 0 ? _state$toJS$doorStyle : null;
+      // let counterTop = state.getIn(['scene', 'layers', layerID, 'counterTop']);
+      // let floorStyle = state.getIn(['scene', 'layers', layerID, 'floorStyle']);
+      var _viewer2D = state.viewer2D;
+      var viewer = state.viewer2D.toJS();
+      _viewer2D = _viewer2D.merge({
+        e: viewer.viewerWidth / 2 - viewer.SVGWidth / 2,
+        f: viewer.viewerHeight / 2 - viewer.SVGHeight / 2,
+        a: 0.99,
+        d: 0.99
+      });
+      state = new State({});
+      state = state.merge({
+        doorStyle: doorStyle,
+        viewer2D: _viewer2D
+      });
+      // state = Item.setCounterTop(state, counterTop).updatedState;
+      // state = Area.setFloorStyles(state, floorStyle).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "loadProject",
+    value: function loadProject(state, sceneJSON) {
+      var doorStyle = state.doorStyle;
+      var layerID = state.scene.selectedLayer;
+      var _viewer2D = state.viewer2D;
+      var viewer = state.viewer2D.toJS();
+      var counterTop = state.getIn(['scene', 'layers', layerID, 'counterTop']);
+      var floorStyle = state.getIn(['scene', 'layers', layerID, 'floorStyle']);
+      var a, e, f;
+      e = viewer.viewerWidth / 2 - viewer.SVGWidth / 2;
+      f = viewer.viewerHeight / 2 - viewer.SVGHeight / 2;
+      _viewer2D = _viewer2D.merge({
+        e: e,
+        f: f,
+        a: 0.99,
+        d: 0.99
+      });
+      var _state2 = state,
+        oldScene = _state2.scene,
+        oldSceneHistory = _state2.sceneHistory;
+      var json_items = sceneJSON.layers[sceneJSON.selectedLayer].items;
+      var elements = state.catalog.get('elements').toArray();
+      var _loop = function _loop(x) {
+        var idx = elements.findIndex(function (it) {
+          return it.itemID === json_items[x].itemID && it.type === json_items[x].category;
+        });
+        if (idx > -1) {
+          json_items[x].name = elements[idx].name;
+          json_items[x].type = elements[idx].name;
+        }
+      };
+      for (var x in json_items) {
+        _loop(x);
+      }
+
+      //  making layer's doorStyle when changing room shape
+      // THIS LOGIC WAS MOVED TO SET INITIAL DOOR STYLE
+      // if (isEmpty(sceneJSON?.layers[layerID]?.doorStyle)) {
+      //   let newlayer = {
+      //     ...sceneJSON?.layers[layerID],
+      //     doorStyle: doorStyle.toJS()
+      //   };
+      //   sceneJSON && (sceneJSON.layers[layerID] = newlayer);
+      // }
+
+      // check type of ceilHeight and make it to Number
+      if (typeof sceneJSON.layers[layerID].ceilHeight !== 'number') sceneJSON.layers[layerID].ceilHeight = Number(sceneJSON.layers[layerID].ceilHeight);
+      var newScene = new Scene(sceneJSON);
+      state = new State({
+        scene: newScene.toJS(),
+        catalog: state.catalog.toJS()
+      });
+      state = state.merge({
+        sceneHistory: history.historyPush(oldSceneHistory, oldScene)
+      });
+      if (state.scene.title === '') {
+        state = state.mergeIn(['scene', 'title'], oldScene.title);
+      }
+
+      //Validate item positions after loading project.
+      state = Item.validateItemPositions(state, layerID).updatedState;
+
+      // get counterTop and floorStyle is after state created from sceneJSON
+      if (state.getIn(['scene', 'layers', layerID, 'counterTop']).uri) {
+        counterTop = state.getIn(['scene', 'layers', layerID, 'counterTop']);
+      }
+      if (state.getIn(['scene', 'layers', layerID, 'floorStyle']).uri) {
+        floorStyle = state.getIn(['scene', 'layers', layerID, 'floorStyle']);
+      }
+      var layer = state.scene.getIn(['layers', state.scene.selectedLayer]);
+      var bb = {
+        minX: Infinity,
+        maxX: -Infinity,
+        minY: Infinity,
+        maxY: -Infinity
+      };
+      bb = layer.vertices.reduce(function (pre, cur) {
+        pre.minX = Math.min(pre.minX, cur.x);
+        pre.maxX = Math.max(pre.maxX, cur.x);
+        pre.minY = Math.min(pre.minY, cur.y);
+        pre.maxY = Math.max(pre.maxY, cur.y);
+        return pre;
+      }, bb);
+      var w = bb.maxX - bb.minX;
+      var h = bb.maxY - bb.minY;
+      if (w != 0 && Math.abs(w) != Infinity && h != 0 && Math.abs(h) != Infinity) {
+        a = viewer.viewerHeight < h ? viewer.viewerHeight / h : (viewer.viewerHeight / h * 3 / 5 - 0.5) / constants.ZOOM_VARIABLE > 400 ? viewer.viewerHeight / h * 400 / ((viewer.viewerHeight / h - 0.5) / constants.ZOOM_VARIABLE) : viewer.viewerHeight / h * 3 / 5;
+        e = (viewer.viewerWidth - (bb.maxX + bb.minX) * a) / 2;
+        f = (viewer.viewerHeight - (viewer.SVGHeight * 2 - bb.maxY - bb.minY) * a) / 2;
+        while (!(e <= 10)) {
+          e -= 0.1;
+        }
+        while (!(e + a * viewer.SVGWidth + 10 >= viewer.viewerWidth)) {
+          e += 0.1;
+        }
+        while (!(f <= 80)) {
+          f -= 0.1;
+        }
+        while (!(f + a * viewer.SVGHeight + 10 >= viewer.viewerHeight)) {
+          f += 0.1;
+        }
+        _viewer2D = _viewer2D.merge({
+          a: a,
+          d: a,
+          e: e,
+          f: f
+        });
+      }
+
+      // Matching state.doorStyle with layer.doorStyle
+      if (state.getIn(['scene', 'layers', layerID, 'doorStyle'])) {
+        doorStyle = state.getIn(['scene', 'layers', layerID, 'doorStyle']);
+      } else if (!isEmpty(doorStyle)) {
+        state = state.setIn(['scene', 'layers', layerID, 'doorStyle'], doorStyle);
+      }
+      state = state.merge({
+        doorStyle: doorStyle,
+        viewer2D: _viewer2D
+      });
+      state = Item.setCounterTop(state, counterTop).updatedState;
+      state = Area.setFloorStyles(state, floorStyle).updatedState;
+      this.updateZoomScale(state, a);
+      viewer2DActions.updateCameraView(_viewer2D);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setProperties",
+    value: function setProperties(state, layerID, properties) {
+      var propJS = properties.toJS();
+      if (propJS && !propJS.altitude) {
+        alert('You can not set width to 0');
+        return {
+          updatedState: state
+        };
+      }
+      state = Layer.setPropertiesOnSelected(state, layerID, properties).updatedState;
+      state = Layer.updateMovingState(state, false).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "updateProperties",
+    value: function updateProperties(state, layerID, properties) {
+      state = Layer.updatePropertiesOnSelected(state, layerID, properties).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setItemsAttributes",
+    value: function setItemsAttributes(state, attributes) {
+      //TODO apply only to items
+      state = Layer.updateMovingState(state, false).updatedState;
+      state.getIn(['scene', 'layers']).forEach(function (layer) {
+        state = Layer.setAttributesOnSelected(state, layer.id, attributes).updatedState;
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setLinesAttributes",
+    value: function setLinesAttributes(state, attributes, isDirect, directData) {
+      //TODO apply only to lines
+      if (!isDirect) {
+        state.getIn(['scene', 'layers']).forEach(function (layer) {
+          state = Layer.setAttributesOnSelected(state, layer.id, attributes).updatedState;
+        });
+      } else if (isDirect && directData !== null) {
+        var layerID = directData.layerID,
+          lineID = directData.lineID;
+        if (layerID && lineID) state = Line.setAttributes(state, layerID, lineID, attributes).updatedState;
+      }
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setHolesAttributes",
+    value: function setHolesAttributes(state, attributes) {
+      //TODO apply only to holes
+      state.getIn(['scene', 'layers']).forEach(function (layer) {
+        state = Layer.setAttributesOnSelected(state, layer.id, attributes).updatedState;
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "unselectAll",
+    value: function unselectAll(state) {
+      state.getIn(['scene', 'layers']).forEach(function (_ref) {
+        var layerID = _ref.id;
+        state = Layer.unselectAll(state, layerID).updatedState;
+      });
+      state.getIn(['scene', 'groups']).forEach(function (group) {
+        state = Group.unselect(state, group.get('id')).updatedState;
+      });
+      var mode = state.getIn(['mode']);
+      if (mode === constants.MODE_DRAGGING_LINE || mode === constants.MODE_DRAGGING_VERTEX) {
+        if (mode.includes('3D')) {
+          state = state.setIn(['mode'], MODE_IDLE_3D);
+        } else state = state.setIn(['mode'], MODE_IDLE);
+        state = state.merge({
+          activeSnapElement: null,
+          snapElements: new List()
+        });
+      }
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "selectAll",
+    value: function selectAll(state, value) {
+      if (value == null) {
+        state.getIn(['scene', 'layers']).forEach(function (_ref2) {
+          var layerID = _ref2.id;
+          state = Layer.selectAll(state, layerID).updatedState;
+        });
+      } else {
+        var layerID = state.getIn(['scene', 'selectedLayer']);
+        var layer = state.scene.layers.get(layerID);
+        layer.items.forEach(function (data) {
+          var x = state.getIn(['scene', 'layers', layerID, 'items', data.id, 'x']);
+          state = state.mergeIn(['scene', 'layers', layerID, 'items', data.id, 'x'], x + value.x);
+          var y = state.getIn(['scene', 'layers', layerID, 'items', data.id, 'y']);
+          state = state.mergeIn(['scene', 'layers', layerID, 'items', data.id, 'y'], y + value.y);
+        });
+        // layer.lines.forEach(data => { state = Layer.selectElement(state, layerID, "lines", data.id).updatedState });
+        // layer.holes.forEach(data => { state = Layer.selectElement(state, layerID, "holes", data.id).updatedState });
+        // layer.areas.forEach(data => { state = Layer.selectElement(state, layerID, "areas", data.id).updatedState });
+        layer.vertices.forEach(function (data) {
+          var x = state.getIn(['scene', 'layers', layerID, 'vertices', data.id, 'x']);
+          state = state.mergeIn(['scene', 'layers', layerID, 'vertices', data.id, 'x'], x + value.x);
+          var y = state.getIn(['scene', 'layers', layerID, 'vertices', data.id, 'y']);
+          state = state.mergeIn(['scene', 'layers', layerID, 'vertices', data.id, 'y'], y + value.y);
+        });
+        return {
+          updatedState: state
+        };
+      }
+      // state.getIn(['scene', 'groups']).forEach(group => { state = Group.unselect(state, group.get('id')).updatedState; });
+
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "remove",
+    value: function remove(state, delObject) {
+      var selectedLayer = state.getIn(['scene', 'selectedLayer']);
+      var _state$getIn = state.getIn(['scene', 'layers', selectedLayer, 'selected']),
+        selectedLines = _state$getIn.lines,
+        selectedHoles = _state$getIn.holes,
+        selectedItems = _state$getIn.items;
+      var relatedLines = [];
+
+      // if deleting element is line then get the related lines that to update walls
+      if (delObject && delObject.prototype === constants.ELEMENT_LINE || isEmpty(delObject) && !isEmpty(selectedLines)) {
+        var allVertices = state.getIn(['scene', 'layers', selectedLayer, 'vertices']).toJS();
+        var selLines = state.getIn(['scene', 'layers', selectedLayer, 'selected', constants.ELEMENT_LINE]).toJS();
+        var curSelLineID = (delObject === null || delObject === void 0 ? void 0 : delObject.prototype) === constants.ELEMENT_LINE ? delObject.id : selLines[0];
+        var delLine = !isEmpty(curSelLineID) && state.getIn(['scene', 'layers', selectedLayer, 'lines', curSelLineID]).toJS();
+        var allLines = state.getIn(['scene', 'layers', selectedLayer, 'lines']).toJS();
+        !isEmpty(delLine) && GeometryUtils.getRelatedLines(relatedLines, delLine, allVertices, allLines);
+      }
+
+      // delete element
+      if (delObject) {
+        switch (delObject.prototype) {
+          case constants.ELEMENT_LINE:
+            state = Line.remove(state, selectedLayer, delObject.id).updatedState;
+            break;
+          case constants.ELEMENT_HOLE:
+            state = Hole.remove(state, selectedLayer, delObject.id).updatedState;
+            break;
+          case constants.ELEMENT_ITEM:
+            state = Item.remove(state, selectedLayer, delObject.id).updatedState;
+            break;
+        }
+      } else {
+        // no specified object, then remove all selected elements
+        selectedLines.forEach(function (lineID) {
+          state = Line.remove(state, selectedLayer, lineID).updatedState;
+        });
+        selectedHoles.forEach(function (holeID) {
+          state = Hole.remove(state, selectedLayer, holeID).updatedState;
+        });
+        selectedItems.forEach(function (itemID) {
+          state = Item.remove(state, selectedLayer, itemID).updatedState;
+        });
+      }
+
+      // update wall if line removed
+      if (!isEmpty(relatedLines)) {
+        state = state.setIn(['mode'], MODE_DRAWING_LINE);
+        relatedLines.forEach(function (relLine, index) {
+          state = Line.select(state, selectedLayer, relLine.id).updatedState;
+          state = Line.applyWallChanges(state, END_DRAWING_LINE).updatedState;
+        });
+      } else {
+        state = Line.applyWallChanges(state, END_DRAWING_LINE).updatedState;
+      }
+      state = Layer.unselectAll(state, selectedLayer).updatedState;
+      var mode = state.getIn(['mode']);
+      if (mode.includes('DRAWING') || mode.includes('DRAGGING') || mode.includes('ROTATING')) {
+        state = state.merge({
+          activeSnapElement: null
+        });
+        if (mode.endsWith('3D')) state = state.setIn(['mode'], MODE_IDLE_3D);else state = state.setIn(['mode'], MODE_IDLE);
+      }
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "undo",
+    value: function undo(state) {
+      var ActiveDrawingHelpers = document.getElementsByName('line_type_ActiveDrawingHelper');
+      ActiveDrawingHelpers.forEach(function (element, index) {
+        element.style.display = 'none';
+      });
+      var sceneHistory = state.sceneHistory;
+      var forRedo = window.forRedo;
+      window.forRedo = forRedo;
+      if (state.scene === sceneHistory.last && sceneHistory.list.size > 1) {
+        sceneHistory = history.historyPop(sceneHistory);
+      }
+      forRedo.push(state.scene);
+      var mode;
+      if (ARRAY_3D_MODES.includes(state.mode)) mode = MODE_IDLE_3D;else mode = MODE_IDLE;
+      state = state.merge({
+        mode: mode,
+        scene: sceneHistory.last,
+        sceneHistory: history.historyPop(sceneHistory)
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "redo",
+    value: function redo(state) {
+      var forRedo = window.forRedo;
+      if (forRedo.length == 0) return {
+        updatedState: state
+      };
+      var scene = forRedo.pop();
+      var mode;
+      if (ARRAY_3D_MODES.includes(state.mode)) mode = MODE_IDLE_3D;else mode = MODE_IDLE;
+      state = state.merge({
+        mode: mode,
+        scene: scene,
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      window.forRedo = forRedo;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "uncreate",
+    value: function uncreate(state) {
+      state = state.merge({
+        popup: false
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "rename",
+    value: function rename(state, name) {
+      state = state.mergeIn(['scene', 'title'], name);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "recreate",
+    value: function recreate(state) {
+      if (state.getIn(['drawingSupport', 'type']) !== undefined) state = state.merge({
+        mode: MODE_DRAWING_ITEM_3D,
+        popup: true
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "shift2don",
+    value: function shift2don(state) {
+      state = state.merge({
+        popup: false
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "shift2doff",
+    value: function shift2doff(state) {
+      if (state.getIn(['drawingSupport', 'type']) !== undefined) {
+        if (state.get('selectedElementsHistory')._tail.array[0].prototype === 'holes') state = state.merge({
+          mode: MODE_DRAWING_HOLE,
+          popup: true
+        });else state = state.merge({
+          mode: MODE_DRAWING_ITEM,
+          popup: true
+        });
+      }
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "rollback",
+    value: function rollback(state) {
+      var sceneHistory = state.sceneHistory;
+      state = this.unselectAll(state).updatedState;
+
+      // if create a design and any elements is not added then no need rollback to last scene state
+      if (!sceneHistory.last && sceneHistory.list.isEmpty()) {
+        return {
+          updatedState: state
+        };
+      }
+
+      // ESC event doesn't need when mode = MODE_IDLE || MODE_IDLE_3D
+      if (state.mode == MODE_IDLE_3D || state.mode == MODE_IDLE) {
+        return {
+          updatedState: state
+        };
+      }
+      var mode;
+      var isLineAction = false;
+      if (state.mode.includes('LINE')) {
+        isLineAction = true;
+      }
+      if (state.mode == MODE_DRAWING_ITEM_3D) {
+        mode = MODE_IDLE_3D;
+        if (state.drawingSupport.has('currentID')) state = Layer.removeElement(state, state.scene.selectedLayer, 'items', state.drawingSupport.get('currentID')).updatedState;
+        state = state.merge({
+          mode: mode,
+          snapElements: new List(),
+          activeSnapElement: null,
+          drawingSupport: new Map(),
+          draggingSupport: new Map(),
+          rotatingSupport: new Map()
+        });
+        return {
+          updatedState: state
+        };
+      }
+
+      // when Add Walls button clicked
+      if (state.mode == MODE_WAITING_DRAWING_LINE) {
+        mode = MODE_IDLE;
+        state = state.merge({
+          mode: mode,
+          snapElements: new List(),
+          activeSnapElement: null,
+          drawingSupport: new Map(),
+          draggingSupport: new Map(),
+          rotatingSupport: new Map()
+        });
+        return {
+          updatedState: state
+        };
+      }
+      if (ARRAY_3D_MODES.includes(state.mode)) mode = MODE_IDLE_3D;else mode = MODE_IDLE;
+      state = state.merge({
+        mode: mode,
+        scene: sceneHistory.last,
+        sceneHistory: history.historyPush(sceneHistory, sceneHistory.last),
+        snapElements: new List(),
+        activeSnapElement: null,
+        drawingSupport: new Map(),
+        draggingSupport: new Map(),
+        rotatingSupport: new Map()
+      });
+      if (isLineAction) {
+        state = Line.applyWallChanges(state, END_DRAWING_LINE).updatedState;
+      }
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "removeDrawingSupport",
+    value: function removeDrawingSupport(state) {
+      var sceneHistory = state.sceneHistory;
+      var mode = state.mode;
+      if (!sceneHistory.last && sceneHistory.list.isEmpty() || mode != MODE_DRAWING_ITEM_3D) {
+        return {
+          updatedState: state
+        };
+      }
+      state = this.unselectAll(state).updatedState;
+      state = state.merge({
+        scene: sceneHistory.last,
+        sceneHistory: history.historyPush(sceneHistory, sceneHistory.last),
+        drawingSupport: new Map()
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setProjectProperties",
+    value: function setProjectProperties(state, properties) {
+      var scene = state.scene.merge(properties);
+      state = state.merge({
+        mode: MODE_IDLE,
+        scene: scene
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setProjectId",
+    value: function setProjectId(state, id) {
+      var scene = state.scene.merge(id);
+      state = state.merge({
+        scene: scene
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "openProjectConfigurator",
+    value: function openProjectConfigurator(state) {
+      state = state.merge({
+        mode: MODE_CONFIGURING_PROJECT
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "initCatalog",
+    value: function initCatalog(state, catalog) {
+      try {
+        state = state.set('catalog', new Catalog(catalog));
+        return {
+          updatedState: state
+        };
+      } catch (error) {
+        console.log('initCatalogError', error);
+        return {
+          updatedState: state
+        };
+      }
+    }
+  }, {
+    key: "addElementToCatalog",
+    value: function addElementToCatalog(state, element) {
+      try {
+        var elements = state.getIn(['catalog', 'elements']).toJS();
+        elements[element.name] = element;
+        var newElements = safeLoadMapList(elements, CatalogElement);
+        state = state.setIn(['catalog', 'elements'], newElements);
+        return {
+          updatedState: state
+        };
+      } catch (error) {
+        console.log('addElementToCatalogError', error);
+        return {
+          updatedState: state
+        };
+      }
+    }
+  }, {
+    key: "updateMouseCoord",
+    value: function updateMouseCoord(state, coords) {
+      state = state.set('mouse', new Map(coords));
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "updateZoomScale",
+    value: function updateZoomScale(state, scale) {
+      state = state.set('zoom', scale);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "toggleSnap",
+    value: function toggleSnap(state, mask) {
+      state = state.set('snapMask', mask);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "throwError",
+    value: function throwError(state, error) {
+      state = state.set('errors', state.get('errors').push({
+        date: Date.now(),
+        error: error
+      }));
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "throwWarning",
+    value: function throwWarning(state, warning) {
+      state = state.set('warnings', state.get('warnings').push({
+        date: Date.now(),
+        warning: warning
+      }));
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "copyProperties",
+    value: function copyProperties(state, properties) {
+      var layerID = state.getIn(['drawingSupport', 'layerID']);
+      var layer = state.getIn(['scene', 'layers', layerID]);
+      if (layer === undefined) return {
+        updatedState: state
+      };else {
+        state = state.merge({
+          mode: MODE_WAITING_DRAWING_LINE,
+          activeSnapElement: null
+        });
+        return {
+          updatedState: state
+        };
+      }
+    }
+  }, {
+    key: "pasteProperties",
+    value: function pasteProperties(state) {
+      state = this.updateProperties(state, state.getIn(['scene', 'selectedLayer']), state.get('clipboardProperties')).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "pushLastSelectedCatalogElementToHistory",
+    value: function pushLastSelectedCatalogElementToHistory(state, element) {
+      var currHistory = state.selectedElementsHistory;
+      var previousPosition = currHistory.findIndex(function (el) {
+        return el.name === element.name;
+      });
+      if (previousPosition !== -1) {
+        currHistory = currHistory.splice(previousPosition, 1);
+      }
+      currHistory = currHistory.splice(0, 0, element);
+      state = state.set('selectedElementsHistory', currHistory);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "changeCatalogPage",
+    value: function changeCatalogPage(state, oldPage, newPage) {
+      state = state.setIn(['catalog', 'page'], newPage).updateIn(['catalog', 'path'], function (path) {
+        return path.push(oldPage);
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "goBackToCatalogPage",
+    value: function goBackToCatalogPage(state, newPage) {
+      var pageIndex = state.catalog.path.findIndex(function (page) {
+        return page === newPage;
+      });
+      state = state.setIn(['catalog', 'page'], newPage).updateIn(['catalog', 'path'], function (path) {
+        return path.take(pageIndex);
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setMode",
+    value: function setMode(state, mode) {
+      state = state.set('mode', mode);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "addHorizontalGuide",
+    value: function addHorizontalGuide(state, coordinate) {
+      state = HorizontalGuide.create(state, coordinate).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "addVerticalGuide",
+    value: function addVerticalGuide(state, coordinate) {
+      state = VerticalGuide.create(state, coordinate).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "addCircularGuide",
+    value: function addCircularGuide(state, x, y, radius) {
+      console.log('adding horizontal guide at', x, y, radius);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "removeHorizontalGuide",
+    value: function removeHorizontalGuide(state, guideID) {
+      state = HorizontalGuide.remove(state, guideID).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "removeVerticalGuide",
+    value: function removeVerticalGuide(state, guideID) {
+      state = VerticalGuide.remove(state, guideID).updatedState;
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "removeCircularGuide",
+    value: function removeCircularGuide(state, guideID) {
+      console.log('removeing horizontal guide ', guideID);
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setStateProperties",
+    value: function setStateProperties(state, properties) {
+      state = state.merge(_objectSpread({}, properties));
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setIsHelp",
+    value: function setIsHelp(state, isHelp) {
+      state = state.merge({
+        isHelp: isHelp
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "setIsCabinetDrawing",
+    value: function setIsCabinetDrawing(state, isCabinetDrawing) {
+      state = state.merge({
+        isCabinetDrawing: isCabinetDrawing
+      });
+      return {
+        updatedState: state
+      };
+    }
+  }, {
+    key: "createRoomWithShape",
+    value: function createRoomWithShape(state, roomShapeType, width, height, measurementUnit, doorStyle) {
+      var catalog = state.catalog;
+      // keep sceneHistory
+      var curLayerID = state.scene.selectedLayer;
+      var ceilHeight = state.getIn(['scene', 'layers', curLayerID, 'ceilHeight']);
+      var sceneHistory = state.getIn(['sceneHistory']);
+      state = this.newProject(state).updatedState;
+      state = state.merge({
+        catalog: catalog
+      });
+      state = Item.setInitialDoorStyle(state, doorStyle).updatedState;
+      var layerID = state.scene.selectedLayer;
+      if (roomShapeType !== constants.ROOM_SHAPE_TYPE.CUSTOM && !isEmpty(width) && !isEmpty(height) && width !== 0 && height !== 0) {
+        var _viewer2D = state.viewer2D;
+        var viewer = _viewer2D.toJS();
+        if (isEmpty(viewer)) return {
+          updatedState: state
+        };
+        width = convert(width).from(measurementUnit).to('cm');
+        height = convert(height).from(measurementUnit).to('cm');
+        var halfWidth = width / 2;
+        var halfHeight = height / 2;
+        var viewerWidth = viewer.SVGWidth;
+        var viewerHeight = viewer.SVGHeight;
+        var centerPos = {
+          x: viewerWidth / 2,
+          y: viewerHeight / 2
+        };
+        var vtLB = {
+          x: centerPos.x - halfWidth,
+          y: centerPos.y - halfHeight
+        };
+        var vtRB = {
+          x: centerPos.x + halfWidth,
+          y: centerPos.y - halfHeight
+        };
+        var vtRT = {
+          x: centerPos.x + halfWidth,
+          y: centerPos.y + halfHeight
+        };
+        var vtLT = {
+          x: centerPos.x - halfWidth,
+          y: centerPos.y + halfHeight
+        };
+        var vertices = [];
+        switch (roomShapeType) {
+          case 'rectangle':
+            vertices = [vtLB, vtLT, vtRT, vtRB];
+            break;
+          case constants.ROOM_SHAPE_TYPE.TWO_WALLS_RIGHT_BOTTOM:
+            vertices = [vtLB, vtRB, vtRT];
+            break;
+          case constants.ROOM_SHAPE_TYPE.TWO_WALLS_RIGHT_TOP:
+            vertices = [vtRB, vtRT, vtLT];
+            break;
+          case constants.ROOM_SHAPE_TYPE.TWO_WALLS_LEFT_TOP:
+            vertices = [vtRT, vtLT, vtLB];
+            break;
+          case constants.ROOM_SHAPE_TYPE.TWO_WALLS_LEFT_BOTTOM:
+            vertices = [vtLT, vtLB, vtRB];
+            break;
+          case constants.ROOM_SHAPE_TYPE.THREE_WALLS_LEFT_TOP_RIGHT:
+            vertices = [vtRB, vtRT, vtLT, vtLB];
+            break;
+          case constants.ROOM_SHAPE_TYPE.THREE_WALLS_TOP_RIGHT_BOTTOM:
+            vertices = [vtLB, vtRB, vtRT, vtLT];
+            break;
+          case constants.ROOM_SHAPE_TYPE.THREE_WALLS_RIGHT_BOTTOM_LEFT:
+            vertices = [vtLT, vtLB, vtRB, vtRT];
+            break;
+          case constants.ROOM_SHAPE_TYPE.THREE_WALLS_BOTTOM_LEFT_TOP:
+            vertices = [vtRT, vtLT, vtLB, vtRB];
+            break;
+        }
+        for (var i = 0; i < vertices.length - 1; i++) {
+          state = Line.create(state, layerID, 'wall', vertices[i].x, vertices[i].y, vertices[i + 1].x, vertices[i + 1].y).updatedState;
+        }
+        if (roomShapeType === constants.ROOM_SHAPE_TYPE.RECTANGLE) {
+          state = Line.create(state, layerID, 'wall', vertices[vertices.length - 1].x, vertices[vertices.length - 1].y, vertices[0].x, vertices[0].y).updatedState;
+        }
+        var layer = state.getIn(['scene', 'layers', layerID]);
+        var lines = layer.getIn(['lines']).toJS();
+        var drawingInfo = {};
+        var lineKey = Object.keys(lines);
+        for (var _i = 0; _i < lineKey.length; _i++) {
+          if (!isEmpty(lineKey)) {
+            drawingInfo.drawingLine = layer.getIn(['lines', lineKey[_i]]);
+          }
+          state = Layer.detectAndUpdateAreas(state, layerID, drawingInfo).updatedState;
+        }
+      }
+
+      // copy keeped sceneHistory
+      state = state.setIn(['scene', 'layers', layerID, 'ceilHeight'], ceilHeight);
+      state = state.setIn(['sceneHistory'], sceneHistory);
+      state = centering2D(state);
+      return {
+        updatedState: state
+      };
+    }
+  }]);
+}();
+export { Project as default };