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

package/src/plugins/autosave.js

@@ -0,0 +1,39 @@
+const sessionStorage = window.hasOwnProperty('sessionStorage')
+  ? window.sessionStorage
+  : false;
+import { loadProject } from '../actions/project-actions';
+
+const TIMEOUT_DELAY = 500;
+
+let timeout = null;
+
+export default function autosave(autosaveKey, revert, delay) {
+  return (store, stateExtractor) => {
+    delay = delay || TIMEOUT_DELAY;
+
+    if (revert === undefined) return;
+    if (!autosaveKey) return;
+    if (!sessionStorage) return;
+
+    //revert
+    if (revert && sessionStorage.getItem(autosaveKey) !== null) {
+      let data = sessionStorage.getItem(autosaveKey);
+      let json = JSON.parse(data);
+      store.dispatch(loadProject(json));
+    }
+
+    //update
+    store.subscribe(() => {
+      if (timeout) clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        let state = stateExtractor(store.getState());
+        // sessionStorage.setItem(autosaveKey, JSON.stringify(state.scene.toJS()));
+        /*let scene = state.sceneHistory.last;
+        if (scene) {
+          let json = JSON.stringify(scene.toJS());
+          sessionStorage.setItem(autosaveKey, json);
+        }*/
+      }, delay);
+    });
+  };
+}

package/src/plugins/console-debugger.js

@@ -0,0 +1,36 @@
+import actions from '../actions/export';
+
+export default function consoleDebugger() {
+  return (store, stateExtractor) => {
+    window.KitchenConfigurator = {
+      ...actions,
+
+      getStore() {
+        return store;
+      },
+
+      getState() {
+        return stateExtractor(store.getState());
+      },
+
+      do(actions, delay = 300) {
+        actions = actions.reverse();
+        let dispatch = store.dispatch;
+        let dispatchAction = () => {
+          console.info(`There are other ${actions.length} actions on stack`);
+          if (actions.length === 0) return;
+          dispatch(actions.pop());
+          if (actions.length === 0) return;
+          setTimeout(dispatchAction, delay);
+        };
+        setTimeout(dispatchAction, 0);
+      }
+    };
+
+    console.groupCollapsed('KitchenConfigurator');
+    console.info('KitchenConfigurator is ready');
+    console.info('console.log(KitchenConfigurator)');
+    console.log(window.KitchenConfigurator);
+    console.groupEnd();
+  };
+}

package/src/plugins/export.js

@@ -0,0 +1,11 @@
+import Autosave from './autosave';
+import Keyboard from './keyboard';
+import ConsoleDebugger from './console-debugger';
+
+export { Autosave, Keyboard, ConsoleDebugger };
+
+export default {
+  Autosave,
+  Keyboard,
+  ConsoleDebugger
+};

package/src/plugins/keyboard.js

@@ -0,0 +1,194 @@
+import {
+  MODE_IDLE,
+  MODE_3D_FIRST_PERSON,
+  MODE_3D_VIEW,
+  MODE_SNAPPING,
+  KEYBOARD_BUTTON_CODE,
+  MODE_IDLE_3D,
+  MODE_ROTATING_ITEM_3D,
+  MODE_DRAGGING_ITEM_3D,
+  MODE_DRAWING_ITEM_3D,
+  MODE_DRAWING_ITEM
+} from '../constants';
+
+import {
+  rollback,
+  undo,
+  redo,
+  recreate,
+  uncreate,
+  remove,
+  toggleSnap,
+  copyProperties,
+  pasteProperties,
+  shift2doff,
+  shift2don
+} from '../actions/project-actions';
+
+export default function keyboard() {
+  return (store, stateExtractor) => {
+    window.addEventListener('keydown', event => {
+      let state = stateExtractor(store.getState());
+      let mode = state.get('mode');
+      switch (event.keyCode) {
+        case KEYBOARD_BUTTON_CODE.BACKSPACE:
+        case KEYBOARD_BUTTON_CODE.DELETE: {
+          if (
+            [
+              MODE_IDLE,
+              MODE_3D_FIRST_PERSON,
+              MODE_3D_VIEW,
+              MODE_IDLE_3D,
+              MODE_ROTATING_ITEM_3D,
+              MODE_DRAGGING_ITEM_3D
+            ].includes(mode)
+          )
+            store.dispatch(remove());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.ESC: {
+          store.dispatch(rollback());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.Z: {
+          if (
+            event.getModifierState('Control') ||
+            event.getModifierState('Meta')
+          )
+            store.dispatch(undo());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.Q: {
+          if (
+            event.getModifierState('Control') ||
+            event.getModifierState('Meta')
+          )
+            store.dispatch(redo());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.ALT: {
+          if (MODE_SNAPPING.includes(mode))
+            store.dispatch(
+              toggleSnap(
+                state.snapMask.merge({
+                  SNAP_POINT: false,
+                  SNAP_LINE: false,
+                  SNAP_SEGMENT: false,
+                  SNAP_GRID: false,
+                  SNAP_GUIDE: false,
+                  tempSnapConfiguartion: state.snapMask.toJS()
+                })
+              )
+            );
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.C: {
+          let selectedLayer = state.getIn(['scene', 'selectedLayer']);
+          let selected = state.getIn([
+            'scene',
+            'layers',
+            selectedLayer,
+            'selected'
+          ]);
+          if (
+            (mode === MODE_IDLE || mode === MODE_3D_VIEW) &&
+            (selected.holes.size ||
+              selected.areas.size ||
+              selected.items.size ||
+              selected.lines.size)
+          ) {
+            if (selected.holes.size) {
+              let hole = state.getIn([
+                'scene',
+                'layers',
+                selectedLayer,
+                'holes',
+                selected.holes.get(0)
+              ]);
+              store.dispatch(copyProperties(hole.get('properties')));
+            } else if (selected.areas.size) {
+              let area = state.getIn([
+                'scene',
+                'layers',
+                selectedLayer,
+                'areas',
+                selected.areas.get(0)
+              ]);
+              store.dispatch(copyProperties(area.properties));
+            } else if (selected.items.size) {
+              let item = state.getIn([
+                'scene',
+                'layers',
+                selectedLayer,
+                'items',
+                selected.items.get(0)
+              ]);
+              store.dispatch(copyProperties(item.properties));
+            } else if (selected.lines.size) {
+              let line = state.getIn([
+                'scene',
+                'layers',
+                selectedLayer,
+                'lines',
+                selected.lines.get(0)
+              ]);
+              store.dispatch(copyProperties(line.properties));
+            }
+          }
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.V: {
+          store.dispatch(pasteProperties());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.SHIFT: {
+          if (
+            ['TEXTAREA', 'INPUT'].includes(document.activeElement.tagName) ===
+            false
+          ) {
+            if ([MODE_DRAWING_ITEM_3D, MODE_IDLE_3D].includes(mode))
+              store.dispatch(recreate());
+            else if ([MODE_DRAWING_ITEM, MODE_IDLE].includes(mode))
+              store.dispatch(shift2doff());
+          }
+          break;
+        }
+      }
+    });
+
+    window.addEventListener('keyup', event => {
+      let state = stateExtractor(store.getState());
+      let mode = state.get('mode');
+
+      switch (event.keyCode) {
+        case KEYBOARD_BUTTON_CODE.ALT: {
+          if (MODE_SNAPPING.includes(mode))
+            store.dispatch(
+              toggleSnap(
+                state.snapMask.merge(
+                  state.snapMask.get('tempSnapConfiguartion')
+                )
+              )
+            );
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.CTRL: {
+          // store.dispatch(setAlterateState());
+          break;
+        }
+        case KEYBOARD_BUTTON_CODE.SHIFT: {
+          if (
+            ['TEXTAREA', 'INPUT'].includes(document.activeElement.tagName) ===
+            false
+          ) {
+            if ([MODE_DRAWING_ITEM_3D, MODE_IDLE_3D].includes(mode))
+              store.dispatch(uncreate());
+            else if ([MODE_DRAWING_ITEM, MODE_IDLE].includes(mode))
+              store.dispatch(shift2don());
+          }
+          break;
+        }
+      }
+    });
+  };
+}

package/src/reducers/areas-reducer.js

@@ -0,0 +1,13 @@
+import { Area } from '../class/export';
+import { SELECT_AREA, SET_FLOOR_STYLES } from '../constants';
+
+export default function (state, action) {
+  switch (action.type) {
+    case SELECT_AREA:
+      return Area.select(state, action.layerID, action.areaID).updatedState;
+    case SET_FLOOR_STYLES:
+      return Area.setFloorStyles(state, action.texture).updatedState;
+    default:
+      return state;
+  }
+}

package/src/reducers/export.js

@@ -0,0 +1,39 @@
+import KitchenConfiguratorAreasReducer from './areas-reducer';
+import KitchenConfiguratorHolesReducer from './holes-reducer';
+import KitchenConfiguratorItemsReducer from './items-reducer';
+import KitchenConfiguratorLinesReducer from './lines-reducer';
+import KitchenConfiguratorGroupsReducer from './groups-reducer';
+import KitchenConfiguratorProjectReducer from './project-reducer';
+import KitchenConfiguratorSceneReducer from './scene-reducer';
+import KitchenConfiguratorVerticesReducer from './vertices-reducer';
+import KitchenConfiguratorViewer2dReducer from './viewer2d-reducer';
+import KitchenConfiguratorViewer3dReducer from './viewer3d-reducer';
+import KitchenConfiguratorUserReducer from './user-reducer';
+
+export {
+  KitchenConfiguratorAreasReducer,
+  KitchenConfiguratorHolesReducer,
+  KitchenConfiguratorItemsReducer,
+  KitchenConfiguratorLinesReducer,
+  KitchenConfiguratorGroupsReducer,
+  KitchenConfiguratorProjectReducer,
+  KitchenConfiguratorSceneReducer,
+  KitchenConfiguratorVerticesReducer,
+  KitchenConfiguratorViewer2dReducer,
+  KitchenConfiguratorViewer3dReducer,
+  KitchenConfiguratorUserReducer
+};
+
+export default {
+  KitchenConfiguratorAreasReducer,
+  KitchenConfiguratorHolesReducer,
+  KitchenConfiguratorItemsReducer,
+  KitchenConfiguratorLinesReducer,
+  KitchenConfiguratorGroupsReducer,
+  KitchenConfiguratorProjectReducer,
+  KitchenConfiguratorSceneReducer,
+  KitchenConfiguratorVerticesReducer,
+  KitchenConfiguratorViewer2dReducer,
+  KitchenConfiguratorViewer3dReducer,
+  KitchenConfiguratorUserReducer
+};

package/src/reducers/groups-reducer.js

@@ -0,0 +1,73 @@
+import { GROUP_ACTIONS } from '../constants';
+import { Group } from '../class/export';
+import { history } from '../utils/export';
+
+export default function (state, action) {
+  state = state.merge({
+    sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+  });
+
+  switch (action.type) {
+    case GROUP_ACTIONS.ADD_GROUP:
+      return Group.create(state).updatedState;
+
+    case GROUP_ACTIONS.ADD_GROUP_FROM_SELECTED:
+      return Group.createFromSelectedElements(state).updatedState;
+
+    case GROUP_ACTIONS.SELECT_GROUP:
+      return Group.select(state, action.groupID).updatedState;
+
+    case GROUP_ACTIONS.UNSELECT_GROUP:
+      return Group.unselect(state, action.groupID).updatedState;
+
+    case GROUP_ACTIONS.ADD_TO_GROUP:
+      return Group.addElement(
+        state,
+        action.groupID,
+        action.layerID,
+        action.elementPrototype,
+        action.elementID
+      ).updatedState;
+
+    case GROUP_ACTIONS.REMOVE_FROM_GROUP:
+      return Group.removeElement(
+        state,
+        action.groupID,
+        action.layerID,
+        action.elementPrototype,
+        action.elementID
+      ).updatedState;
+
+    case GROUP_ACTIONS.SET_GROUP_ATTRIBUTES:
+      return Group.setAttributes(state, action.groupID, action.attributes)
+        .updatedState;
+
+    case GROUP_ACTIONS.SET_GROUP_PROPERTIES:
+      return Group.setProperties(state, action.groupID, action.properties)
+        .updatedState;
+
+    case GROUP_ACTIONS.SET_GROUP_BARYCENTER:
+      return Group.setBarycenter(
+        state,
+        action.groupID,
+        action.barycenter.get('x'),
+        action.barycenter.get('y')
+      ).updatedState;
+
+    case GROUP_ACTIONS.REMOVE_GROUP:
+      return Group.remove(state, action.groupID).updatedState;
+
+    case GROUP_ACTIONS.REMOVE_GROUP_AND_DELETE_ELEMENTS:
+      return Group.removeAndDeleteElements(state, action.groupID).updatedState;
+
+    case GROUP_ACTIONS.GROUP_TRANSLATE:
+      return Group.translate(state, action.groupID, action.x, action.y)
+        .updatedState;
+
+    case GROUP_ACTIONS.GROUP_ROTATE:
+      return Group.rotate(state, action.groupID, action.rotation).updatedState;
+
+    default:
+      return state;
+  }
+}

package/src/reducers/holes-reducer.js

@@ -0,0 +1,125 @@
+import { Hole } from '../class/export';
+import { history } from '../utils/export';
+import {
+  SELECT_TOOL_DRAWING_HOLE,
+  SELECT_TOOL_DRAWING_HOLE_3D,
+  UPDATE_DRAWING_HOLE,
+  UPDATE_DRAWING_HOLE_3D,
+  END_DRAWING_HOLE,
+  END_DRAWING_HOLE_3D,
+  BEGIN_DRAGGING_HOLE,
+  BEGIN_DRAGGING_HOLE_3D,
+  UPDATE_DRAGGING_HOLE,
+  END_DRAGGING_HOLE,
+  END_DRAGGING_HOLE_3D,
+  SELECT_HOLE,
+  END_CREATING_HOLE,
+  UPDATE_POPUP_OPEN,
+  UPDATE_DRAGGING_HOLE_CHANGED,
+  UPDATE_DRAGGING_HOLE_RULER_CHANGED
+} from '../constants';
+
+export default function (state, action) {
+  switch (action.type) {
+    case UPDATE_DRAGGING_HOLE_RULER_CHANGED:
+      return Hole.updateDraggingHoleRulerChanged(
+        state,
+        action.width,
+        action.layerID,
+        action.holeID
+      ).updatedState;
+
+    case UPDATE_DRAGGING_HOLE_CHANGED:
+      return Hole.updateDraggingHoleChanged(
+        state,
+        action.x,
+        action.y,
+        action.layerID,
+        action.holeID
+      ).updatedState;
+
+    case END_CREATING_HOLE:
+      return Hole.endCreatingHole(state).updatedState;
+
+    case UPDATE_POPUP_OPEN:
+      return Hole.updatePopupOpen(state, action.value).updatedState;
+
+    case SELECT_TOOL_DRAWING_HOLE:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.selectToolDrawingHole(state, action.sceneComponentType)
+        .updatedState;
+
+    case SELECT_TOOL_DRAWING_HOLE_3D:
+      return Hole.selectToolDrawingHole3D(state, action.sceneComponentType)
+        .updatedState;
+
+    case UPDATE_DRAWING_HOLE:
+      return Hole.updateDrawingHole(state, action.layerID, action.x, action.y)
+        .updatedState;
+
+    case UPDATE_DRAWING_HOLE_3D:
+      return Hole.updateDrawingHole3D(state, action.layerID, action.x, action.y)
+        .updatedState;
+
+    case END_DRAWING_HOLE:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.endDrawingHole(state, action.layerID, action.x, action.y)
+        .updatedState;
+
+    case END_DRAWING_HOLE_3D:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.endDrawingHole3D(state, action.layerID, action.x, action.y)
+        .updatedState;
+
+    case BEGIN_DRAGGING_HOLE:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.beginDraggingHole(
+        state,
+        action.layerID,
+        action.holeID,
+        action.x,
+        action.y
+      ).updatedState;
+
+    case BEGIN_DRAGGING_HOLE_3D:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.beginDraggingHole3D(
+        state,
+        action.layerID,
+        action.holeID,
+        action.x,
+        action.y
+      ).updatedState;
+
+    case UPDATE_DRAGGING_HOLE:
+      return Hole.updateDraggingHole(state, action.x, action.y).updatedState;
+
+    case END_DRAGGING_HOLE:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.endDraggingHole(state, action.x, action.y).updatedState;
+
+    case END_DRAGGING_HOLE_3D:
+      state = state.merge({
+        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+      });
+      return Hole.endDraggingHole3D(state, action.x, action.y).updatedState;
+
+    case SELECT_HOLE:
+      return Hole.select(state, action.layerID, action.holeID).updatedState;
+
+    default:
+      return state;
+  }
+}