kitchen-simulator 5.0.0-test.3 → 5.0.0-test.5

package/src/class/project.js

@@ -1,875 +0,0 @@
-import { List, Map } from 'immutable';
-import * as constants from '../constants';
-import {
-  ARRAY_3D_MODES,
-  MODE_CONFIGURING_PROJECT,
-  MODE_DRAWING_HOLE,
-  MODE_DRAWING_ITEM,
-  MODE_DRAWING_ITEM_3D,
-  MODE_IDLE,
-  MODE_IDLE_3D,
-  MODE_VIEWING_CATALOG,
-  MODE_WAITING_DRAWING_LINE
-} from '../constants';
-import { Catalog, Scene, State } from '../models';
-import { history } from '../utils/export';
-import { isEmpty } from '../utils/helper';
-import {
-  Area,
-  Group,
-  Hole,
-  HorizontalGuide,
-  Item,
-  Layer,
-  Line,
-  VerticalGuide
-} from '../class/export';
-import * as viewer2DActions from '../actions/viewer2d-actions';
-
-class Project {
-  static setAlterate(state) {
-    return { updatedState: state.set('alterate', !state.alterate) };
-  }
-
-  static openCatalog(state) {
-    state = this.setMode(state, MODE_VIEWING_CATALOG).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static newProject(state) {
-    let doorStyle =
-      state.toJS().doorStyle === null ? null : state.toJS().doorStyle;
-    let oStyle = state.oStyle;
-    // let counterTop = state.getIn(['scene', 'layers', layerID, 'counterTop']);
-    // let floorStyle = state.getIn(['scene', 'layers', layerID, 'floorStyle']);
-    let _viewer2D = state.viewer2D;
-    let 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,
-      oStyle: oStyle,
-      viewer2D: _viewer2D
-    });
-    // state = Item.setCounterTop(state, counterTop).updatedState;
-    // state = Area.setFloorStyles(state, floorStyle).updatedState;
-    return { updatedState: state };
-  }
-
-  static loadProject(state, sceneJSON, categoryData) {
-    console.log({
-      sceneJSON,
-      categoryData
-    });
-    let doorStyle = state.doorStyle;
-    let oStyle = state.oStyle;
-    let layerID = state.scene.selectedLayer;
-    let _viewer2D = state.viewer2D;
-    let viewer = state.viewer2D.toJS();
-    let counterTop = state.getIn(['scene', 'layers', layerID, 'counterTop']);
-    let floorStyle = state.getIn(['scene', 'layers', layerID, 'floorStyle']);
-
-    let 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
-    });
-
-    let { scene: oldScene, sceneHistory: oldSceneHistory } = state;
-    let json_items = sceneJSON.layers[sceneJSON.selectedLayer].items;
-    let elements = state.catalog.get('elements').toArray();
-    for (let x in json_items) {
-      let idx = elements.findIndex(
-        it =>
-          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;
-      }
-    }
-    let 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']);
-    }
-    const layer = state.scene.getIn(['layers', state.scene.selectedLayer]);
-    let bb = {
-      minX: Infinity,
-      maxX: -Infinity,
-      minY: Infinity,
-      maxY: -Infinity
-    };
-    bb = layer.vertices.reduce((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);
-
-    let w = bb.maxX - bb.minX;
-    let 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
-      });
-    }
-    if (!doorStyle) {
-      if (state.getIn(['scene', 'layers', layerID, 'doorStyle'])) {
-        doorStyle = state.getIn(['scene', 'layers', layerID, 'doorStyle']);
-      }
-    }
-
-    state = state.merge({
-      doorStyle: doorStyle,
-      oStyle: oStyle,
-      viewer2D: _viewer2D
-    });
-    state = Item.setCounterTop(state, counterTop).updatedState;
-    state = Area.setFloorStyles(state, floorStyle).updatedState;
-    if (
-      state.getIn(['scene', 'layers', layerID, 'doorStyle']) &&
-      !state.getIn(['scene', 'layers', layerID, 'doorStyle', 'install'])
-    ) {
-      let layerDoorStyle = state.getIn([
-        'scene',
-        'layers',
-        layerID,
-        'doorStyle'
-      ]);
-      let install = '';
-      categoryData.data.doorStyles.items.forEach(category => {
-        category.items.forEach(element => {
-          if (
-            element.items.filter(
-              it =>
-                it.id === layerDoorStyle.id &&
-                (layerDoorStyle.install
-                  ? category.name === layerDoorStyle.install
-                  : true)
-            ).length
-          ) {
-            install = category.name;
-          }
-        });
-      });
-      layerDoorStyle = { ...layerDoorStyle, install: install };
-      state = state.mergeIn(
-        ['scene', 'layers', layerID, 'doorStyle'],
-        layerDoorStyle
-      );
-    }
-    this.updateZoomScale(state, a);
-    viewer2DActions.updateCameraView(_viewer2D);
-    return { updatedState: state };
-  }
-
-  static setProperties(state, layerID, properties) {
-    let 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 };
-  }
-
-  static updateProperties(state, layerID, properties) {
-    state = Layer.updatePropertiesOnSelected(
-      state,
-      layerID,
-      properties
-    ).updatedState;
-    return { updatedState: state };
-  }
-
-  static setItemsAttributes(state, attributes) {
-    //TODO apply only to items
-    state = Layer.updateMovingState(state, false).updatedState;
-    state.getIn(['scene', 'layers']).forEach(layer => {
-      state = Layer.setAttributesOnSelected(
-        state,
-        layer.id,
-        attributes
-      ).updatedState;
-    });
-
-    return { updatedState: state };
-  }
-
-  static setLinesAttributes(state, attributes, isDirect, directData) {
-    //TODO apply only to lines
-    if (!isDirect) {
-      state.getIn(['scene', 'layers']).forEach(layer => {
-        state = Layer.setAttributesOnSelected(
-          state,
-          layer.id,
-          attributes
-        ).updatedState;
-      });
-    } else if (isDirect && directData !== null) {
-      const { layerID, lineID } = directData;
-      if (layerID && lineID)
-        state = Line.setAttributes(
-          state,
-          layerID,
-          lineID,
-          attributes
-        ).updatedState;
-    }
-    return { updatedState: state };
-  }
-
-  static setHolesAttributes(state, attributes) {
-    //TODO apply only to holes
-    state.getIn(['scene', 'layers']).forEach(layer => {
-      state = Layer.setAttributesOnSelected(
-        state,
-        layer.id,
-        attributes
-      ).updatedState;
-    });
-
-    return { updatedState: state };
-  }
-
-  static unselectAll(state) {
-    state.getIn(['scene', 'layers']).forEach(({ id: layerID }) => {
-      state = Layer.unselectAll(state, layerID).updatedState;
-    });
-    state.getIn(['scene', 'groups']).forEach(group => {
-      state = Group.unselect(state, group.get('id')).updatedState;
-    });
-    let 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 };
-  }
-
-  static selectAll(state, value) {
-    if (value == null) {
-      state.getIn(['scene', 'layers']).forEach(({ id: layerID }) => {
-        state = Layer.selectAll(state, layerID).updatedState;
-      });
-    } else {
-      let layerID = state.getIn(['scene', 'selectedLayer']);
-      let layer = state.scene.layers.get(layerID);
-      layer.items.forEach(data => {
-        let x = state.getIn([
-          'scene',
-          'layers',
-          layerID,
-          'items',
-          data.id,
-          'x'
-        ]);
-        state = state.mergeIn(
-          ['scene', 'layers', layerID, 'items', data.id, 'x'],
-          x + value.x
-        );
-        let 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(data => {
-        let x = state.getIn([
-          'scene',
-          'layers',
-          layerID,
-          'vertices',
-          data.id,
-          'x'
-        ]);
-        state = state.mergeIn(
-          ['scene', 'layers', layerID, 'vertices', data.id, 'x'],
-          x + value.x
-        );
-        let 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 };
-  }
-
-  static remove(state) {
-    let selectedLayer = state.getIn(['scene', 'selectedLayer']);
-    let {
-      lines: selectedLines,
-      holes: selectedHoles,
-      items: selectedItems
-    } = state.getIn(['scene', 'layers', selectedLayer, 'selected']);
-    let lineID = selectedLines.first();
-    let allVertices = state
-      .getIn(['scene', 'layers', selectedLayer, 'vertices'])
-      .toJS();
-    let selLines = state
-      .getIn(['scene', 'layers', selectedLayer, 'selected', 'lines'])
-      .toJS();
-    let delLine =
-      !isEmpty(lineID) &&
-      state.getIn(['scene', 'layers', selectedLayer, 'lines', lineID]).toJS();
-
-    let line = state.getIn(['scene', 'layers', selectedLayer, 'lines', lineID]);
-
-    state = Layer.unselectAll(state, selectedLayer).updatedState;
-
-    selectedLines.forEach(lineID => {
-      state = Line.remove(state, selectedLayer, lineID).updatedState;
-    });
-    selectedHoles.forEach(holeID => {
-      state = Hole.remove(state, selectedLayer, holeID).updatedState;
-    });
-    selectedItems.forEach(itemID => {
-      state = Item.remove(state, selectedLayer, itemID).updatedState;
-    });
-
-    let allLine = state.getIn(['scene', 'layers', selectedLayer, 'lines']);
-    if (!isEmpty(lineID)) {
-      const resultInterior = Layer.interiorsurfacedetect(
-        state,
-        delLine,
-        allVertices,
-        allLine,
-        selectedLayer
-      );
-      if (!isEmpty(resultInterior)) {
-        state = resultInterior.updatedState;
-      }
-    }
-
-    /// 180 merge lines - start ////
-    let vertexGroup = [];
-
-    if (!isEmpty(line)) {
-      line.vertices.forEach(vertexID => {
-        let colinearLines = state.getIn([
-          'scene',
-          'layers',
-          selectedLayer,
-          'vertices',
-          vertexID,
-          'lines'
-        ]);
-        if (!isEmpty(colinearLines)) {
-          vertexGroup.push(vertexID);
-          colinearLines.forEach(lineID => {
-            let line = state.getIn([
-              'scene',
-              'layers',
-              selectedLayer,
-              'lines',
-              lineID
-            ]);
-
-            line.vertices.forEach(vertex => {
-              if (vertex !== vertexID) vertexGroup.push(vertex);
-            });
-          });
-        }
-      });
-
-      vertexGroup.forEach(vertexId => {
-        let lineGroup = [];
-
-        lineGroup = Line.hasColinearTwoLines(state, vertexId, selectedLayer);
-        if (!isEmpty(lineGroup)) {
-          state = Line.mergeTwoColinearLines(
-            state,
-            lineGroup[0],
-            lineGroup[1],
-            selectedLayer,
-            line.properties
-          ).updatedState;
-        }
-      });
-    }
-    /// 180 merge lines - end ////
-
-    state = Layer.detectAndUpdateAreas(state, selectedLayer, {}).updatedState;
-    let 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 };
-  }
-
-  static undo(state) {
-    let ActiveDrawingHelpers = document.getElementsByName(
-      'line_type_ActiveDrawingHelper'
-    );
-    ActiveDrawingHelpers.forEach((element, index) => {
-      element.style.display = 'none';
-    });
-    let sceneHistory = state.sceneHistory;
-    let forRedo = window.forRedo;
-    window.forRedo = forRedo;
-    if (state.scene === sceneHistory.last && sceneHistory.list.size > 1) {
-      sceneHistory = history.historyPop(sceneHistory);
-    }
-    forRedo.push(state.scene);
-    let 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 };
-  }
-
-  static redo(state) {
-    let forRedo = window.forRedo;
-    if (forRedo.length == 0) return { updatedState: state };
-    let scene = forRedo.pop();
-    let 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 };
-  }
-
-  static uncreate(state) {
-    state = state.merge({
-      popup: false
-    });
-    return { updatedState: state };
-  }
-
-  static rename(state, name) {
-    state = state.mergeIn(['scene', 'title'], name);
-    return { updatedState: state };
-  }
-
-  static recreate(state) {
-    if (state.getIn(['drawingSupport', 'type']) !== undefined)
-      state = state.merge({
-        mode: MODE_DRAWING_ITEM_3D,
-        popup: true
-      });
-    return { updatedState: state };
-  }
-
-  static shift2don(state) {
-    state = state.merge({
-      popup: false
-    });
-    return { updatedState: state };
-  }
-
-  static 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 };
-  }
-
-  static rollback(state) {
-    let 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 };
-    }
-
-    let mode;
-    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()
-    });
-    return { updatedState: state };
-  }
-
-  static removeDrawingSupport(state) {
-    let sceneHistory = state.sceneHistory;
-    let 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 };
-  }
-
-  static setProjectProperties(state, properties) {
-    let scene = state.scene.merge(properties);
-    state = state.merge({
-      mode: MODE_IDLE,
-      scene
-    });
-
-    return { updatedState: state };
-  }
-
-  static setProjectId(state, id) {
-    let scene = state.scene.merge(id);
-    state = state.merge({
-      scene
-    });
-
-    return { updatedState: state };
-  }
-
-  static openProjectConfigurator(state) {
-    state = state.merge({
-      mode: MODE_CONFIGURING_PROJECT
-    });
-
-    return { updatedState: state };
-  }
-
-  static initCatalog(state, catalog) {
-    try {
-      state = state.set('catalog', new Catalog(catalog));
-      return { updatedState: state };
-    } catch (error) {
-      console.log('initCatalogError', error);
-      return { updatedState: state };
-    }
-  }
-
-  static updateMouseCoord(state, coords) {
-    state = state.set('mouse', new Map(coords));
-
-    return { updatedState: state };
-  }
-
-  static updateZoomScale(state, scale) {
-    state = state.set('zoom', scale);
-
-    return { updatedState: state };
-  }
-
-  static toggleSnap(state, mask) {
-    state = state.set('snapMask', mask);
-    return { updatedState: state };
-  }
-
-  static throwError(state, error) {
-    state = state.set(
-      'errors',
-      state.get('errors').push({
-        date: Date.now(),
-        error
-      })
-    );
-
-    return { updatedState: state };
-  }
-
-  static throwWarning(state, warning) {
-    state = state.set(
-      'warnings',
-      state.get('warnings').push({
-        date: Date.now(),
-        warning
-      })
-    );
-
-    return { updatedState: state };
-  }
-
-  static copyProperties(state, properties) {
-    let layerID = state.getIn(['drawingSupport', 'layerID']);
-    let 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 };
-    }
-  }
-
-  static pasteProperties(state) {
-    state = this.updateProperties(
-      state,
-      state.getIn(['scene', 'selectedLayer']),
-      state.get('clipboardProperties')
-    ).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static pushLastSelectedCatalogElementToHistory(state, element) {
-    let currHistory = state.selectedElementsHistory;
-
-    let previousPosition = currHistory.findIndex(
-      el => 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 };
-  }
-
-  static changeCatalogPage(state, oldPage, newPage) {
-    state = state
-      .setIn(['catalog', 'page'], newPage)
-      .updateIn(['catalog', 'path'], path => path.push(oldPage));
-
-    return { updatedState: state };
-  }
-
-  static goBackToCatalogPage(state, newPage) {
-    let pageIndex = state.catalog.path.findIndex(page => page === newPage);
-    state = state
-      .setIn(['catalog', 'page'], newPage)
-      .updateIn(['catalog', 'path'], path => path.take(pageIndex));
-
-    return { updatedState: state };
-  }
-
-  static setMode(state, mode) {
-    state = state.set('mode', mode);
-    return { updatedState: state };
-  }
-
-  static addHorizontalGuide(state, coordinate) {
-    state = HorizontalGuide.create(state, coordinate).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static addVerticalGuide(state, coordinate) {
-    state = VerticalGuide.create(state, coordinate).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static addCircularGuide(state, x, y, radius) {
-    console.log('adding horizontal guide at', x, y, radius);
-
-    return { updatedState: state };
-  }
-
-  static removeHorizontalGuide(state, guideID) {
-    state = HorizontalGuide.remove(state, guideID).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static removeVerticalGuide(state, guideID) {
-    state = VerticalGuide.remove(state, guideID).updatedState;
-
-    return { updatedState: state };
-  }
-
-  static removeCircularGuide(state, guideID) {
-    console.log('removeing horizontal guide ', guideID);
-
-    return { updatedState: state };
-  }
-
-  static setStateProperties(state, properties) {
-    state = state.merge({
-      ...properties
-    });
-    return { updatedState: state };
-  }
-
-  static setIsHelp(state, isHelp) {
-    state = state.merge({
-      isHelp: isHelp
-    });
-    return { updatedState: state };
-  }
-
-  static setIsCabinetDrawing(state, isCabinetDrawing) {
-    state = state.merge({
-      isCabinetDrawing: isCabinetDrawing
-    });
-    return { updatedState: state };
-  }
-}
-
-export { Project as default };