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

package/es/class/project.js

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