kitchen-simulator
Version:
It is a kitchen simulator (self-contained micro-frontend).
198 lines • 7.22 kB
JavaScript
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import { List, Map } from 'immutable';
import { Vertex as VertexModel } from "../models";
import { GeometryUtils, IDBroker, SnapSceneUtils, SnapUtils } from "../utils/export";
import { END_DRAGGING_VERTEX, MODE_DRAGGING_VERTEX } from "../constants";
import { Layer, Line } from "../class/export";
import { isEmpty } from "../utils/helper";
var Vertex = /*#__PURE__*/function () {
function Vertex() {
_classCallCheck(this, Vertex);
}
return _createClass(Vertex, null, [{
key: "add",
value: function add(state, layerID, x, y, relatedPrototype, relatedID) {
var vertex = state.getIn(['scene', 'layers', layerID, 'vertices']).find(function (vertex) {
return GeometryUtils.samePoints(vertex, {
x: x,
y: y
});
});
if (vertex) {
vertex = vertex.update(relatedPrototype, function (related) {
return related.push(relatedID);
});
} else {
vertex = new VertexModel(_defineProperty({
id: IDBroker.acquireID(),
name: 'Vertex',
x: x,
y: y
}, relatedPrototype, new List([relatedID])));
}
state = state.setIn(['scene', 'layers', layerID, 'vertices', vertex.id], vertex);
return {
updatedState: state,
vertex: vertex
};
}
}, {
key: "setAttributes",
value: function setAttributes(state, layerID, vertexID, vertexAttributes) {
state = state.mergeIn(['scene', 'layers', layerID, 'vertices', vertexID], vertexAttributes);
return {
updatedState: state
};
}
}, {
key: "addElement",
value: function addElement(state, layerID, vertexID, elementPrototype, elementID) {
state = state.updateIn(['scene', 'layers', layerID, 'vertices', vertexID, elementPrototype], function (list) {
return list.push(elementID);
});
return {
updatedState: state
};
}
}, {
key: "removeElement",
value: function removeElement(state, layerID, vertexID, elementPrototype, elementID) {
var elementIndex = state.getIn(['scene', 'layers', layerID, 'vertices', vertexID, elementPrototype]).findIndex(function (el) {
return el === elementID;
});
if (elementIndex !== -1) {
state = state.updateIn(['scene', 'layers', layerID, 'vertices', vertexID, elementPrototype], function (list) {
return list.remove(elementIndex);
});
}
return {
updatedState: state
};
}
}, {
key: "select",
value: function select(state, layerID, vertexID) {
state = state.setIn(['scene', 'layers', layerID, 'vertices', vertexID, 'selected'], true);
state = state.updateIn(['scene', 'layers', layerID, 'selected', 'vertices'], function (elems) {
return elems.push(vertexID);
});
return {
updatedState: state
};
}
}, {
key: "unselect",
value: function unselect(state, layerID, vertexID) {
state = state.setIn(['scene', 'layers', layerID, 'vertices', vertexID, 'selected'], false);
state = state.updateIn(['scene', 'layers', layerID, 'selected', 'vertices'], function (elems) {
return elems.filter(function (el) {
return el.id !== vertexID;
});
});
return {
updatedState: state
};
}
}, {
key: "remove",
value: function remove(state, layerID, vertexID, relatedPrototype, relatedID, forceRemove) {
var vertex = state.getIn(['scene', 'layers', layerID, 'vertices', vertexID]);
if (vertex) {
if (relatedPrototype && relatedID) vertex = vertex.update(relatedPrototype, function (related) {
var index = related.findIndex(function (ID) {
return relatedID === ID;
});
return related["delete"](index);
});
var inUse = vertex.areas.size || vertex.lines.size;
if (inUse && !forceRemove) {
state = state.setIn(['scene', 'layers', layerID, 'vertices', vertexID], vertex);
} else {
state = state.deleteIn(['scene', 'layers', layerID, 'vertices', vertexID]);
}
}
return {
updatedState: state
};
}
}, {
key: "beginDraggingVertex",
value: function beginDraggingVertex(state, layerID, vertexID, x, y) {
var snapElements = SnapSceneUtils.sceneSnapElements(state.scene, new List(), state.snapMask);
state = state.merge({
mode: MODE_DRAGGING_VERTEX,
snapElements: snapElements,
draggingSupport: Map({
layerID: layerID,
vertexID: vertexID,
previousMode: state.get('mode')
})
});
return {
updatedState: state
};
}
}, {
key: "updateDraggingVertex",
value: function updateDraggingVertex(state, x, y) {
var _state = state,
draggingSupport = _state.draggingSupport,
snapElements = _state.snapElements,
scene = _state.scene;
var snap = null;
if (state.snapMask && !state.snapMask.isEmpty()) {
snap = SnapUtils.nearestSnap(snapElements, x, y, state.snapMask);
if (snap) {
var _snap$point = snap.point;
x = _snap$point.x;
y = _snap$point.y;
}
}
var layerID = draggingSupport.get('layerID');
var vertexID = draggingSupport.get('vertexID');
state = state.merge({
activeSnapElement: snap ? snap.snap : null,
scene: scene.mergeIn(['layers', layerID, 'vertices', vertexID], {
x: x,
y: y
})
});
return {
updatedState: state
};
}
}, {
key: "endDraggingVertex",
value: function endDraggingVertex(state, x, y) {
var _state2 = state,
draggingSupport = _state2.draggingSupport;
var layerID = draggingSupport.get('layerID');
var vertexID = draggingSupport.get('vertexID');
var lines = state.getIn(['scene', 'layers', layerID, 'vertices', vertexID, 'lines']);
if (!isEmpty(lines)) {
state = lines.reduce(function (reducedState, lineID) {
var eachLine = reducedState.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if (isEmpty(eachLine)) return reducedState;
reducedState = Layer.removeZeroLengthLines(reducedState, layerID).updatedState;
reducedState = Layer.mergeEqualsVertices(reducedState, layerID, vertexID).updatedState;
reducedState = Line.select(reducedState, layerID, eachLine.id).updatedState;
reducedState = reducedState.setIn(['mode'], MODE_DRAGGING_VERTEX);
reducedState = Line.applyWallChanges(reducedState, END_DRAGGING_VERTEX).updatedState;
return reducedState;
}, state);
}
state = state.merge({
mode: draggingSupport.get('previousMode'),
draggingSupport: null,
activeSnapElement: null,
snapElements: new List()
});
return {
updatedState: state
};
}
}]);
}();
export { Vertex as default };