kitchen-simulator 1.1.1-test.63 → 1.1.1-test.65

package/es/class/line.js

@@ -1,22 +1,31 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { fromJS, List, Map } from 'immutable';
-import { Group, Hole, Layer, Vertex } from "./export";
-import { GeometryUtils, history, IDBroker, NameGenerator, SnapSceneUtils, SnapUtils } from "../utils/export";
-import * as Three from 'three';
-import { END_DRAGGING_LINE, END_DRAGGING_VERTEX, END_DRAWING_LINE, EPSILON, MIN_ANGLE_DISALLOW_DRAW_WALL, MODE_DRAGGING_LINE, MODE_DRAWING_LINE, MODE_IDLE, MODE_WAITING_DRAWING_LINE, UNIT_ANGLE } from "../constants";
-import { isEmpty } from "../utils/helper";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _immutable = require("immutable");
+var _export = require("./export");
+var _export2 = require("../utils/export");
+var Three = _interopRequireWildcard(require("three"));
+var _constants = require("../constants");
+var _helper = require("../utils/helper");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 var timeGlobal = 0;
 var TimeRecorder = /*#__PURE__*/function () {
   function TimeRecorder(name) {
-    _classCallCheck(this, TimeRecorder);
+    (0, _classCallCheck2["default"])(this, TimeRecorder);
     this.name = name;
     if (name === 'beginDrawingLine') {
       console.log('time__  Start Drawing');
     }
   }
-  return _createClass(TimeRecorder, [{
+  return (0, _createClass2["default"])(TimeRecorder, [{
     key: "start",
     value: function start() {
       this.first = Date.now();
@@ -35,11 +44,11 @@ var TimeRecorder = /*#__PURE__*/function () {
     }
   }]);
 }();
-var Line = /*#__PURE__*/function () {
+var Line = exports["default"] = /*#__PURE__*/function () {
   function Line() {
-    _classCallCheck(this, Line);
+    (0, _classCallCheck2["default"])(this, Line);
   }
-  return _createClass(Line, null, [{
+  return (0, _createClass2["default"])(Line, null, [{
     key: "create",
     value: function create(state, layerID, type, x0, y0, x1, y1, properties) {
       var lineCreatedDateTime = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : new Date().getTime();
@@ -48,18 +57,18 @@ var Line = /*#__PURE__*/function () {
       //   return { updatedState: state };
       // }
       // ///////////////
-      var lineID = IDBroker.acquireID();
-      var _Vertex$add = Vertex.add(state, layerID, x0, y0, 'lines', lineID),
+      var lineID = _export2.IDBroker.acquireID();
+      var _Vertex$add = _export.Vertex.add(state, layerID, x0, y0, 'lines', lineID),
         stateV0 = _Vertex$add.updatedState,
         v0 = _Vertex$add.vertex;
-      var _Vertex$add2 = Vertex.add(stateV0, layerID, x1, y1, 'lines', lineID),
+      var _Vertex$add2 = _export.Vertex.add(stateV0, layerID, x1, y1, 'lines', lineID),
         stateV1 = _Vertex$add2.updatedState,
         v1 = _Vertex$add2.vertex;
       state = stateV1;
       var line = state.catalog.factoryElement(type, {
         id: lineID,
-        name: NameGenerator.generateName('lines', state.catalog.getIn(['elements', type, 'info', 'title'])),
-        vertices: new List([v0.id, v1.id]),
+        name: _export2.NameGenerator.generateName('lines', state.catalog.getIn(['elements', type, 'info', 'title'])),
+        vertices: new _immutable.List([v0.id, v1.id]),
         type: type
       }, properties);
       line = line.set('createdDateTime', lineCreatedDateTime !== undefined ? lineCreatedDateTime : new Date().getTime());
@@ -81,7 +90,7 @@ var Line = /*#__PURE__*/function () {
     value: function select(state, layerID, lineID) {
       var _line$vertices, _line$vertices$get, _line$vertices2, _line$vertices2$get;
       // Try selecting the layer first
-      var layerResult = Layer.select(state, layerID);
+      var layerResult = _export.Layer.select(state, layerID);
       if (!layerResult || !layerResult.updatedState) {
         return {
           updatedState: state
@@ -98,7 +107,7 @@ var Line = /*#__PURE__*/function () {
       }
 
       // Select the line element
-      var lineSelectResult = Layer.selectElement(state, layerID, 'lines', lineID);
+      var lineSelectResult = _export.Layer.selectElement(state, layerID, 'lines', lineID);
       if (lineSelectResult !== null && lineSelectResult !== void 0 && lineSelectResult.updatedState) {
         state = lineSelectResult.updatedState;
       }
@@ -106,7 +115,7 @@ var Line = /*#__PURE__*/function () {
       // Select the first vertex (if available)
       var firstVertex = (_line$vertices = line.vertices) === null || _line$vertices === void 0 || (_line$vertices$get = _line$vertices.get) === null || _line$vertices$get === void 0 ? void 0 : _line$vertices$get.call(_line$vertices, 0);
       if (firstVertex !== undefined) {
-        var v1Result = Layer.selectElement(state, layerID, 'vertices', firstVertex);
+        var v1Result = _export.Layer.selectElement(state, layerID, 'vertices', firstVertex);
         if (v1Result !== null && v1Result !== void 0 && v1Result.updatedState) {
           state = v1Result.updatedState;
         }
@@ -115,7 +124,7 @@ var Line = /*#__PURE__*/function () {
       // Select the second vertex (if available)
       var secondVertex = (_line$vertices2 = line.vertices) === null || _line$vertices2 === void 0 || (_line$vertices2$get = _line$vertices2.get) === null || _line$vertices2$get === void 0 ? void 0 : _line$vertices2$get.call(_line$vertices2, 1);
       if (secondVertex !== undefined) {
-        var v2Result = Layer.selectElement(state, layerID, 'vertices', secondVertex);
+        var v2Result = _export.Layer.selectElement(state, layerID, 'vertices', secondVertex);
         if (v2Result !== null && v2Result !== void 0 && v2Result.updatedState) {
           state = v2Result.updatedState;
         }
@@ -131,14 +140,14 @@ var Line = /*#__PURE__*/function () {
       if (line) {
         state = this.unselect(state, layerID, lineID).updatedState;
         line.holes.forEach(function (holeID) {
-          return state = Hole.remove(state, layerID, holeID).updatedState;
+          return state = _export.Hole.remove(state, layerID, holeID).updatedState;
         });
-        state = Layer.removeElement(state, layerID, 'lines', lineID).updatedState;
+        state = _export.Layer.removeElement(state, layerID, 'lines', lineID).updatedState;
         line.vertices.forEach(function (vertexID) {
-          return state = Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
+          return state = _export.Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
         });
         state.getIn(['scene', 'groups']).forEach(function (group) {
-          return state = Group.removeElement(state, group.id, layerID, 'lines', lineID).updatedState;
+          return state = _export.Group.removeElement(state, group.id, layerID, 'lines', lineID).updatedState;
         });
       }
       return {
@@ -168,9 +177,9 @@ var Line = /*#__PURE__*/function () {
     value: function unselect(state, layerID, lineID) {
       var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
       if (line) {
-        state = Layer.unselect(state, layerID, 'vertices', line.vertices.get(0)).updatedState;
-        state = Layer.unselect(state, layerID, 'vertices', line.vertices.get(1)).updatedState;
-        state = Layer.unselect(state, layerID, 'lines', lineID).updatedState;
+        state = _export.Layer.unselect(state, layerID, 'vertices', line.vertices.get(0)).updatedState;
+        state = _export.Layer.unselect(state, layerID, 'vertices', line.vertices.get(1)).updatedState;
+        state = _export.Layer.unselect(state, layerID, 'lines', lineID).updatedState;
       }
       return {
         updatedState: state
@@ -193,8 +202,8 @@ var Line = /*#__PURE__*/function () {
         stateL2 = _Line$create2.updatedState,
         line1 = _Line$create2.line;
       state = stateL2;
-      var splitPointOffset = GeometryUtils.pointPositionOnLineSegment(x0, y0, x1, y1, x, y);
-      var minVertex = GeometryUtils.minVertex(v0, v1);
+      var splitPointOffset = _export2.GeometryUtils.pointPositionOnLineSegment(x0, y0, x1, y1, x, y);
+      var minVertex = _export2.GeometryUtils.minVertex(v0, v1);
       line.holes.forEach(function (holeID) {
         var hole = state.getIn(['scene', 'layers', layerID, 'holes', holeID]);
         var holeOffset = hole.offset;
@@ -209,7 +218,7 @@ var Line = /*#__PURE__*/function () {
             offset = 1 - offset;
           }
             */
-          state = Hole.create(state, layerID, hole.type, line0.id, offset, hole.properties).updatedState;
+          state = _export.Hole.create(state, layerID, hole.type, line0.id, offset, hole.properties).updatedState;
         } else {
           var _offset = (holeOffset - splitPointOffset) / (1 - splitPointOffset);
           /*
@@ -217,7 +226,7 @@ var Line = /*#__PURE__*/function () {
             offset = 1 - offset;
           }
             */
-          state = Hole.create(state, layerID, hole.type, line1.id, _offset, hole.properties).updatedState;
+          state = _export.Hole.create(state, layerID, hole.type, line1.id, _offset, hole.properties).updatedState;
         }
       });
 
@@ -227,13 +236,13 @@ var Line = /*#__PURE__*/function () {
         return lines && lines.contains(lineID);
       });
       lineGroups.forEach(function (group) {
-        state = Group.addElement(state, group.id, layerID, 'lines', line0.id).updatedState;
-        state = Group.addElement(state, group.id, layerID, 'lines', line1.id).updatedState;
+        state = _export.Group.addElement(state, group.id, layerID, 'lines', line0.id).updatedState;
+        state = _export.Group.addElement(state, group.id, layerID, 'lines', line1.id).updatedState;
       });
       state = Line.remove(state, layerID, lineID).updatedState;
       return {
         updatedState: state,
-        lines: new List([line0, line1])
+        lines: new _immutable.List([line0, line1])
       };
     }
   }, {
@@ -241,7 +250,7 @@ var Line = /*#__PURE__*/function () {
     value: function addFromPoints(state, layerID, type, points, properties, holes) {
       var _this = this;
       var lineCreatedDateTime = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Date().getTime();
-      points = new List(points).sort(function (_ref, _ref2) {
+      points = new _immutable.List(points).sort(function (_ref, _ref2) {
         var x1 = _ref.x,
           y1 = _ref.y;
         var x2 = _ref2.x,
@@ -249,7 +258,7 @@ var Line = /*#__PURE__*/function () {
         return x1 === x2 ? y1 - y2 : x1 - x2;
       });
       var pointsPair = points.zip(points.skip(1)).filterNot(function (_ref3) {
-        var _ref4 = _slicedToArray(_ref3, 2),
+        var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
           _ref4$ = _ref4[0],
           x1 = _ref4$.x,
           y1 = _ref4$.y,
@@ -260,7 +269,7 @@ var Line = /*#__PURE__*/function () {
       });
       var lines = [];
       pointsPair.forEach(function (_ref5) {
-        var _ref6 = _slicedToArray(_ref5, 2),
+        var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
           _ref6$ = _ref6[0],
           x1 = _ref6$.x,
           y1 = _ref6$.y,
@@ -271,10 +280,10 @@ var Line = /*#__PURE__*/function () {
           stateL = _this$create.updatedState,
           line = _this$create.line;
         state = stateL;
-        var lineLength = GeometryUtils.pointsDistance(x1, y1, x2, y2);
-        var alpha = GeometryUtils.absAngleBetweenTwoPoints(x1, y1, x2, y2);
-        var cosAlpha = GeometryUtils.cosWithThreshold(Math.abs(alpha), 0.0000001);
-        var sinAlpha = GeometryUtils.sinWithThreshold(Math.abs(alpha), 0.0000001);
+        var lineLength = _export2.GeometryUtils.pointsDistance(x1, y1, x2, y2);
+        var alpha = _export2.GeometryUtils.absAngleBetweenTwoPoints(x1, y1, x2, y2);
+        var cosAlpha = _export2.GeometryUtils.cosWithThreshold(Math.abs(alpha), 0.0000001);
+        var sinAlpha = _export2.GeometryUtils.sinWithThreshold(Math.abs(alpha), 0.0000001);
         if (holes) {
           holes.forEach(function (holeWithOffsetPoint) {
             var offset = holeWithOffsetPoint.hole.toJS().offset;
@@ -282,16 +291,16 @@ var Line = /*#__PURE__*/function () {
             var _holeWithOffsetPoint$ = holeWithOffsetPoint.offsetPosition,
               xp = _holeWithOffsetPoint$.x,
               yp = _holeWithOffsetPoint$.y;
-            if (GeometryUtils.isPointOnLineSegment(x1, y1, x2, y2, xp, yp)) {
-              var newOffset = GeometryUtils.pointPositionOnLineSegment(x1, y1, x2, y2, xp, yp);
+            if (_export2.GeometryUtils.isPointOnLineSegment(x1, y1, x2, y2, xp, yp)) {
+              var newOffset = _export2.GeometryUtils.pointPositionOnLineSegment(x1, y1, x2, y2, xp, yp);
               if (newOffset >= 0 && newOffset <= 1) {
                 //add the position of hole
-                var temp = Hole.create(state, layerID, holeWithOffsetPoint.hole.type, line.id, newOffset, holeWithOffsetPoint.hole.properties, xp, yp);
+                var temp = _export.Hole.create(state, layerID, holeWithOffsetPoint.hole.type, line.id, newOffset, holeWithOffsetPoint.hole.properties, xp, yp);
                 state = temp.updatedState;
                 var holeX = 0,
                   holeY = 0,
                   holeID = temp.hole.id;
-                if (GeometryUtils.almostEqual(y1, y2)) {
+                if (_export2.GeometryUtils.almostEqual(y1, y2)) {
                   if (x1 > x2) {
                     holeX = x1 - lineLength * newOffset;
                     holeY = y1;
@@ -299,7 +308,7 @@ var Line = /*#__PURE__*/function () {
                     holeX = x1 + lineLength * newOffset;
                     holeY = y1;
                   }
-                } else if (GeometryUtils.almostEqual(x1, x2)) {
+                } else if (_export2.GeometryUtils.almostEqual(x1, x2)) {
                   if (y1 > y2) {
                     holeX = x1;
                     holeY = y1 - lineLength * newOffset;
@@ -334,7 +343,7 @@ var Line = /*#__PURE__*/function () {
       });
       return {
         updatedState: state,
-        lines: new List(lines),
+        lines: new _immutable.List(lines),
         newline: lines[0]
       };
     }
@@ -354,21 +363,21 @@ var Line = /*#__PURE__*/function () {
         var _line$vertices$map$to = line.vertices.map(function (vertexID) {
             return reducedState.getIn(['scene', 'layers', layerID, 'vertices']).get(vertexID);
           }).toArray(),
-          _line$vertices$map$to2 = _slicedToArray(_line$vertices$map$to, 2),
+          _line$vertices$map$to2 = (0, _slicedToArray2["default"])(_line$vertices$map$to, 2),
           v0 = _line$vertices$map$to2[0],
           v1 = _line$vertices$map$to2[1];
-        var hasCommonEndpoint = GeometryUtils.samePoints(v0, points[0]) || GeometryUtils.samePoints(v0, points[1]) || GeometryUtils.samePoints(v1, points[0]) || GeometryUtils.samePoints(v1, points[1]);
-        var intersection = GeometryUtils.twoLineSegmentsIntersection(points[0], points[1], v0, v1);
+        var hasCommonEndpoint = _export2.GeometryUtils.samePoints(v0, points[0]) || _export2.GeometryUtils.samePoints(v0, points[1]) || _export2.GeometryUtils.samePoints(v1, points[0]) || _export2.GeometryUtils.samePoints(v1, points[1]);
+        var intersection = _export2.GeometryUtils.twoLineSegmentsIntersection(points[0], points[1], v0, v1);
         if (intersection.type === 'colinear') {
           if (!oldHoles) {
             oldHoles = [];
           }
-          var orderedVertices = GeometryUtils.orderVertices(points);
+          var orderedVertices = _export2.GeometryUtils.orderVertices(points);
           reducedState.getIn(['scene', 'layers', layerID, 'lines', line.id, 'holes']).forEach(function (holeID) {
             var hole = reducedState.getIn(['scene', 'layers', layerID, 'holes', holeID]);
-            var oldLineLength = GeometryUtils.pointsDistance(v0.x, v0.y, v1.x, v1.y);
-            var offset = GeometryUtils.samePoints(orderedVertices[1], line.vertices.get(1)) ? 1 - hole.offset : hole.offset;
-            var offsetPosition = GeometryUtils.extendLine(v0.x, v0.y, v1.x, v1.y, oldLineLength * offset);
+            var oldLineLength = _export2.GeometryUtils.pointsDistance(v0.x, v0.y, v1.x, v1.y);
+            var offset = _export2.GeometryUtils.samePoints(orderedVertices[1], line.vertices.get(1)) ? 1 - hole.offset : hole.offset;
+            var offsetPosition = _export2.GeometryUtils.extendLine(v0.x, v0.y, v1.x, v1.y, oldLineLength * offset);
             oldHoles.push({
               hole: hole,
               offsetPosition: offsetPosition
@@ -397,8 +406,8 @@ var Line = /*#__PURE__*/function () {
     key: "replaceVertex",
     value: function replaceVertex(state, layerID, lineID, vertexIndex, x, y) {
       var vertexID = state.getIn(['scene', 'layers', layerID, 'lines', lineID, 'vertices', vertexIndex]);
-      state = Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
-      var _Vertex$add3 = Vertex.add(state, layerID, x, y, 'lines', lineID),
+      state = _export.Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
+      var _Vertex$add3 = _export.Vertex.add(state, layerID, x, y, 'lines', lineID),
         stateV = _Vertex$add3.updatedState,
         vertex = _Vertex$add3.vertex;
       state = stateV;
@@ -414,8 +423,8 @@ var Line = /*#__PURE__*/function () {
     key: "selectToolDrawingLine",
     value: function selectToolDrawingLine(state, sceneComponentType) {
       state = state.merge({
-        mode: MODE_WAITING_DRAWING_LINE,
-        drawingSupport: new Map({
+        mode: _constants.MODE_WAITING_DRAWING_LINE,
+        drawingSupport: new _immutable.Map({
           type: sceneComponentType
         })
       });
@@ -427,16 +436,16 @@ var Line = /*#__PURE__*/function () {
     key: "beginDrawingLine",
     value: function beginDrawingLine(state, layerID, x, y) {
       // if end drawing by created area
-      if (state.mode == MODE_IDLE) {
+      if (state.mode == _constants.MODE_IDLE) {
         return {
           updatedState: state
         };
       }
       // ///////////////
-      var snapElements = SnapSceneUtils.sceneSnapElements(state.scene, new List(), state.snapMask);
+      var snapElements = _export2.SnapSceneUtils.sceneSnapElements(state.scene, new _immutable.List(), state.snapMask);
       var snap = null;
       if (state.snapMask && !state.snapMask.isEmpty()) {
-        snap = SnapUtils.nearestSnap(snapElements, x, y, state.snapMask);
+        snap = _export2.SnapUtils.nearestSnap(snapElements, x, y, state.snapMask);
         if (snap) {
           var _snap$point = snap.point;
           x = _snap$point.x;
@@ -444,36 +453,36 @@ var Line = /*#__PURE__*/function () {
         }
         snapElements = snapElements.withMutations(function (snapElements) {
           var a, b, c;
-          var _GeometryUtils$horizo = GeometryUtils.horizontalLine(y);
+          var _GeometryUtils$horizo = _export2.GeometryUtils.horizontalLine(y);
           a = _GeometryUtils$horizo.a;
           b = _GeometryUtils$horizo.b;
           c = _GeometryUtils$horizo.c;
-          SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
-          var _GeometryUtils$vertic = GeometryUtils.verticalLine(x);
+          _export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
+          var _GeometryUtils$vertic = _export2.GeometryUtils.verticalLine(x);
           a = _GeometryUtils$vertic.a;
           b = _GeometryUtils$vertic.b;
           c = _GeometryUtils$vertic.c;
-          SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
-          var _GeometryUtils$upcros = GeometryUtils.upcrossLine(x, y);
+          _export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
+          var _GeometryUtils$upcros = _export2.GeometryUtils.upcrossLine(x, y);
           a = _GeometryUtils$upcros.a;
           b = _GeometryUtils$upcros.b;
           c = _GeometryUtils$upcros.c;
-          SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
-          var _GeometryUtils$downcr = GeometryUtils.downcrossLine(x, y);
+          _export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
+          var _GeometryUtils$downcr = _export2.GeometryUtils.downcrossLine(x, y);
           a = _GeometryUtils$downcr.a;
           b = _GeometryUtils$downcr.b;
           c = _GeometryUtils$downcr.c;
-          SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
+          _export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
         });
       }
       var drawingSupport = state.get('drawingSupport').set('layerID', layerID);
-      state = Layer.unselectAll(state, layerID).updatedState;
+      state = _export.Layer.unselectAll(state, layerID).updatedState;
       var _Line$create3 = Line.create(state, layerID, drawingSupport.get('type'), x, y, x, y),
         stateL = _Line$create3.updatedState,
         line = _Line$create3.line;
       state = Line.select(stateL, layerID, line.id).updatedState;
       state = state.merge({
-        mode: MODE_DRAWING_LINE,
+        mode: _constants.MODE_DRAWING_LINE,
         snapElements: snapElements,
         activeSnapElement: snap ? snap.snap : null,
         drawingSupport: drawingSupport
@@ -487,7 +496,7 @@ var Line = /*#__PURE__*/function () {
     value: function updateDrawingLine(state, x, y, relatedLines) {
       var snap = null;
       if (state.snapMask && !state.snapMask.isEmpty()) {
-        snap = SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
+        snap = _export2.SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
         if (snap) {
           var _snap$point2 = snap.point;
           x = _snap$point2.x;
@@ -503,7 +512,7 @@ var Line = /*#__PURE__*/function () {
       var moveFlag = true;
       var tx = vertices[drawingLine.vertices[1]].x;
       var ty = vertices[drawingLine.vertices[1]].y;
-      if (!isEmpty(relatedLines)) {
+      if (!(0, _helper.isEmpty)(relatedLines)) {
         vertices[drawingLine.vertices[1]].x = x;
         vertices[drawingLine.vertices[1]].y = y;
       }
@@ -513,12 +522,12 @@ var Line = /*#__PURE__*/function () {
       if (drawingLine.vertices[0] !== drawingLine.vertices[1]) {
         relatedLines.forEach(function (line) {
           // get the points of two lines(drawing line and related line)
-          if (!isEmpty(line)) {
+          if (!(0, _helper.isEmpty)(line)) {
             // the angle between two lines(line, drawingLine)
-            lineAngle = GeometryUtils.angleBetweenTwoLines(line, drawingLine, vertices);
+            lineAngle = _export2.GeometryUtils.angleBetweenTwoLines(line, drawingLine, vertices);
             // check whether the angle is less than or bigger than specific value.
             absAngle = Math.abs(lineAngle);
-            if (absAngle < MIN_ANGLE_DISALLOW_DRAW_WALL || absAngle > 360 - MIN_ANGLE_DISALLOW_DRAW_WALL) {
+            if (absAngle < _constants.MIN_ANGLE_DISALLOW_DRAW_WALL || absAngle > 360 - _constants.MIN_ANGLE_DISALLOW_DRAW_WALL) {
               moveFlag = false;
             } else moveFlag = true;
           }
@@ -530,20 +539,20 @@ var Line = /*#__PURE__*/function () {
         tx = x;
         ty = y;
       } else {
-        var rest = MIN_ANGLE_DISALLOW_DRAW_WALL - absAngle;
+        var rest = _constants.MIN_ANGLE_DISALLOW_DRAW_WALL - absAngle;
         // the origin point of rotation(snapping)
         var ox = vertices[drawingLine.vertices[0]].x;
         var oy = vertices[drawingLine.vertices[0]].y;
         // determine the direction of rotation.
         rest = lineAngle > 0 ? -rest : rest;
         // rotate the current point to last point around the first point of drawing line.
-        var res = GeometryUtils.rotatePointAroundPoint(x, y, ox, oy, rest);
+        var res = _export2.GeometryUtils.rotatePointAroundPoint(x, y, ox, oy, rest);
         tx = res.x;
         ty = res.y;
       }
       // angle snapping as a value of UNIT_ANGLE
-      if (moveFlag && !isEmpty(absAngle) && absAngle % UNIT_ANGLE !== 0) {
-        var result = GeometryUtils.snapAngleByUnit(lineAngle, vertices, drawingLine, tx, ty, drawingLine.vertices[1]);
+      if (moveFlag && !(0, _helper.isEmpty)(absAngle) && absAngle % _constants.UNIT_ANGLE !== 0) {
+        var result = _export2.GeometryUtils.snapAngleByUnit(lineAngle, vertices, drawingLine, tx, ty, drawingLine.vertices[1]);
         tx = result.x;
         ty = result.y;
       }
@@ -573,9 +582,9 @@ var Line = /*#__PURE__*/function () {
       var _layer$lines$get;
       var holeOffset = [];
       (_layer$lines$get = layer.lines.get(lineID)) === null || _layer$lines$get === void 0 || _layer$lines$get.holes.forEach(function (holeID) {
-        var lineLength = GeometryUtils.pointsDistance(nv0.x, nv0.y, nv1.x, nv1.y);
-        var minV = GeometryUtils.minVertex(nv0, nv1);
-        var maxV = GeometryUtils.maxVertex(nv0, nv1);
+        var lineLength = _export2.GeometryUtils.pointsDistance(nv0.x, nv0.y, nv1.x, nv1.y);
+        var minV = _export2.GeometryUtils.minVertex(nv0, nv1);
+        var maxV = _export2.GeometryUtils.maxVertex(nv0, nv1);
         var alpha = Math.atan2(maxV.y - minV.y, maxV.x - minV.x);
         var hole = layer.holes.get(holeID);
         var pointOnLine = lineLength * hole.offset;
@@ -616,7 +625,7 @@ var Line = /*#__PURE__*/function () {
               return mgline.id === lineID;
             });
           });
-          if (!isEmpty(relatedLineID)) {
+          if (!(0, _helper.isEmpty)(relatedLineID)) {
             var relatedLine = layer.lines.get(relatedLineID[0]);
             var intersectionPoint = vertex;
             var startPoint, endPoint;
@@ -633,8 +642,8 @@ var Line = /*#__PURE__*/function () {
             var tline2 = {
               vertices: [intersectionPoint.id, endPoint.id]
             };
-            var angle = Math.abs(GeometryUtils.angleBetweenTwoLines(tline1, tline2, allVertices.toJS()));
-            if (Math.abs(angle - 180) <= EPSILON) {
+            var angle = Math.abs(_export2.GeometryUtils.angleBetweenTwoLines(tline1, tline2, allVertices.toJS()));
+            if (Math.abs(angle - 180) <= _constants.EPSILON) {
               selectedLineInfo.mergelines.push(relatedLine);
               selectedLineInfo.points[0] = startPoint;
               selectedLineInfo.points[1] = endPoint;
@@ -652,7 +661,7 @@ var Line = /*#__PURE__*/function () {
       var allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']);
       var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
       var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
-      if (isEmpty(line)) {
+      if ((0, _helper.isEmpty)(line)) {
         return {
           updatedState: state
         };
@@ -684,13 +693,13 @@ var Line = /*#__PURE__*/function () {
       var holesWithOffsetPosition = [];
       var lineID = layer.getIn(['selected', 'lines']).first(); // lines : [id]
       var line = layer.getIn(['lines', lineID]);
-      if (isEmpty(line)) {
+      if ((0, _helper.isEmpty)(line)) {
         return {
           updatedState: state
         };
       }
       mergeInfo.mergelines.forEach(function (line) {
-        if ([END_DRAGGING_LINE, END_DRAGGING_VERTEX].includes(actionType)) {
+        if ([_constants.END_DRAGGING_LINE, _constants.END_DRAGGING_VERTEX].includes(actionType)) {
           var tmpGroups = state //get groups membership if present
           .getIn(['scene', 'groups']).filter(function (group) {
             var lines = group.getIn(['elements', layerID, 'lines']);
@@ -709,20 +718,20 @@ var Line = /*#__PURE__*/function () {
         state = Line.remove(state, layerID, line.id).updatedState;
       });
       var ret;
-      if (!GeometryUtils.samePoints(mergeInfo.points[0], mergeInfo.points[1])) {
+      if (!_export2.GeometryUtils.samePoints(mergeInfo.points[0], mergeInfo.points[1])) {
         ret = Line.createAvoidingIntersections(state, layerID, line.type, mergeInfo.points[0].x, mergeInfo.points[0].y, mergeInfo.points[1].x, mergeInfo.points[1].y, line.properties, holesWithOffsetPosition, line.createdDateTime);
         state = ret.updatedState;
       }
-      if ([END_DRAGGING_LINE, END_DRAGGING_VERTEX].includes(actionType)) {
+      if ([_constants.END_DRAGGING_LINE, _constants.END_DRAGGING_VERTEX].includes(actionType)) {
         //re-add to old line's groups if present
         ret.lines.forEach(function (addedLine) {
           lineGroups.forEach(function (oldLineGroup) {
-            state = Group.addElement(state, oldLineGroup.id, layerID, 'lines', addedLine.id).updatedState;
+            state = _export.Group.addElement(state, oldLineGroup.id, layerID, 'lines', addedLine.id).updatedState;
           });
         });
       }
-      state = Layer.removeZeroLengthLines(state, layerID).updatedState;
-      if (!isEmpty((_ret = ret) === null || _ret === void 0 ? void 0 : _ret.newline)) {
+      state = _export.Layer.removeZeroLengthLines(state, layerID).updatedState;
+      if (!(0, _helper.isEmpty)((_ret = ret) === null || _ret === void 0 ? void 0 : _ret.newline)) {
         state = this.select(state, layerID, ret.newline.get('id')).updatedState;
       }
       return {
@@ -737,10 +746,10 @@ var Line = /*#__PURE__*/function () {
       var lineID = layer.getIn(['selected', 'lines']).first(); // lines : [id]
       var line = layer.getIn(['lines', lineID]);
       var drawingInfo = {};
-      if (!isEmpty(line)) {
+      if (!(0, _helper.isEmpty)(line)) {
         drawingInfo.drawingLine = line;
       }
-      state = Layer.detectAndUpdateAreas(state, layerID, drawingInfo).updatedState;
+      state = _export.Layer.detectAndUpdateAreas(state, layerID, drawingInfo).updatedState;
       return {
         updatedState: state
       };
@@ -762,16 +771,16 @@ var Line = /*#__PURE__*/function () {
       var layerID = state.getIn(['scene', 'selectedLayer']);
       var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
       var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
-      if (isEmpty(line)) {
+      if ((0, _helper.isEmpty)(line)) {
         return {
           updatedState: state
         };
       }
-      if (!isEmpty(v0)) {
+      if (!(0, _helper.isEmpty)(v0)) {
         state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0), 'x'], v0.x);
         state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0), 'y'], v0.y);
       }
-      if (!isEmpty(v1)) {
+      if (!(0, _helper.isEmpty)(v1)) {
         state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1), 'x'], v1.x);
         state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1), 'y'], v1.y);
       }
@@ -785,7 +794,7 @@ var Line = /*#__PURE__*/function () {
     key: "endDrawingLine",
     value: function endDrawingLine(state, x, y) {
       if (state.snapMask && !state.snapMask.isEmpty()) {
-        var snap = SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
+        var snap = _export2.SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
         if (snap) {
           var _snap$point3 = snap.point;
           x = _snap$point3.x;
@@ -798,8 +807,8 @@ var Line = /*#__PURE__*/function () {
       if (drawingLine.vertices[0] === drawingLine.vertices[1]) {
         state = Line.remove(state, layerID, lineID).updatedState;
         state = state.merge({
-          mode: MODE_IDLE,
-          snapElements: new List(),
+          mode: _constants.MODE_IDLE,
+          snapElements: new _immutable.List(),
           activeSnapElement: null
         });
         return {
@@ -810,10 +819,10 @@ var Line = /*#__PURE__*/function () {
         x: x,
         y: y
       }, state).updatedState;
-      state = this.applyWallChanges(state, END_DRAWING_LINE).updatedState;
+      state = this.applyWallChanges(state, _constants.END_DRAWING_LINE).updatedState;
       state = state.merge({
-        mode: MODE_WAITING_DRAWING_LINE,
-        snapElements: new List(),
+        mode: _constants.MODE_WAITING_DRAWING_LINE,
+        snapElements: new _immutable.List(),
         activeSnapElement: null
       });
       return {
@@ -823,15 +832,15 @@ var Line = /*#__PURE__*/function () {
   }, {
     key: "beginDraggingLine",
     value: function beginDraggingLine(state, layerID, lineID, x, y) {
-      var snapElements = SnapSceneUtils.sceneSnapElements(state.scene, new List(), state.snapMask);
+      var snapElements = _export2.SnapSceneUtils.sceneSnapElements(state.scene, new _immutable.List(), state.snapMask);
       var layer = state.scene.layers.get(layerID);
       var line = layer.lines.get(lineID);
       var vertex0 = layer.vertices.get(line.vertices.get(0));
       var vertex1 = layer.vertices.get(line.vertices.get(1));
       state = state.merge({
-        mode: MODE_DRAGGING_LINE,
+        mode: _constants.MODE_DRAGGING_LINE,
         snapElements: snapElements,
-        draggingSupport: Map({
+        draggingSupport: (0, _immutable.Map)({
           layerID: layerID,
           lineID: lineID,
           startPointX: x,
@@ -869,7 +878,7 @@ var Line = /*#__PURE__*/function () {
           var vec1 = pos1.clone().sub(cen).normalize();
           var vec2 = pos2.clone().sub(cen).normalize();
           var angle = Math.floor(vec1.angle() * 180 / Math.PI - vec2.angle() * 180 / Math.PI + 0.5);
-          if (Math.abs(angle) < MIN_ANGLE_DISALLOW_DRAW_WALL || Math.abs(angle) > 360 - MIN_ANGLE_DISALLOW_DRAW_WALL) {
+          if (Math.abs(angle) < _constants.MIN_ANGLE_DISALLOW_DRAW_WALL || Math.abs(angle) > 360 - _constants.MIN_ANGLE_DISALLOW_DRAW_WALL) {
             mvFlag.push(false);
           } else {
             mvFlag.push(true);
@@ -909,8 +918,8 @@ var Line = /*#__PURE__*/function () {
       var curSnap0 = null,
         curSnap1 = null;
       if (state.snapMask && !state.snapMask.isEmpty()) {
-        curSnap0 = SnapUtils.nearestSnap(snapElements, newVertex0X, newVertex0Y, state.snapMask);
-        curSnap1 = SnapUtils.nearestSnap(snapElements, newVertex1X, newVertex1Y, state.snapMask);
+        curSnap0 = _export2.SnapUtils.nearestSnap(snapElements, newVertex0X, newVertex0Y, state.snapMask);
+        curSnap1 = _export2.SnapUtils.nearestSnap(snapElements, newVertex1X, newVertex1Y, state.snapMask);
       }
       var deltaX = 0,
         deltaY = 0;
@@ -994,8 +1003,8 @@ var Line = /*#__PURE__*/function () {
       var newVertex1X = draggingSupport.get('startVertex1X') + diffX;
       var newVertex1Y = draggingSupport.get('startVertex1Y') + diffY;
       if (state.snapMask && !state.snapMask.isEmpty()) {
-        var curSnap0 = SnapUtils.nearestSnap(state.snapElements, newVertex0X, newVertex0Y, state.snapMask);
-        var curSnap1 = SnapUtils.nearestSnap(state.snapElements, newVertex1X, newVertex1Y, state.snapMask);
+        var curSnap0 = _export2.SnapUtils.nearestSnap(state.snapElements, newVertex0X, newVertex0Y, state.snapMask);
+        var curSnap1 = _export2.SnapUtils.nearestSnap(state.snapElements, newVertex1X, newVertex1Y, state.snapMask);
         var deltaX = 0,
           deltaY = 0;
         if (curSnap0 && curSnap1) {
@@ -1032,9 +1041,9 @@ var Line = /*#__PURE__*/function () {
       newVertex0Y = newResult.newVertex0Y;
       newVertex1X = newResult.newVertex1X;
       newVertex1Y = newResult.newVertex1Y;
-      state = Layer.mergeEqualsVertices(state, layerID, line.vertices.get(0)).updatedState;
-      state = Layer.mergeEqualsVertices(state, layerID, line.vertices.get(1)).updatedState;
-      if (GeometryUtils.samePoints({
+      state = _export.Layer.mergeEqualsVertices(state, layerID, line.vertices.get(0)).updatedState;
+      state = _export.Layer.mergeEqualsVertices(state, layerID, line.vertices.get(1)).updatedState;
+      if (_export2.GeometryUtils.samePoints({
         newVertex0X: newVertex0X,
         newVertex0Y: newVertex0Y
       }, {
@@ -1050,13 +1059,13 @@ var Line = /*#__PURE__*/function () {
           x: newVertex1X,
           y: newVertex1Y
         }, state).updatedState;
-        state = this.applyWallChanges(state, END_DRAGGING_LINE).updatedState;
+        state = this.applyWallChanges(state, _constants.END_DRAGGING_LINE).updatedState;
       }
       state = state.merge({
-        mode: MODE_IDLE,
+        mode: _constants.MODE_IDLE,
         draggingSupport: null,
         activeSnapElement: null,
-        snapElements: new List()
+        snapElements: new _immutable.List()
       });
       return {
         updatedState: state
@@ -1073,7 +1082,7 @@ var Line = /*#__PURE__*/function () {
   }, {
     key: "setJsProperties",
     value: function setJsProperties(state, layerID, lineID, properties) {
-      return this.setProperties(state, layerID, lineID, fromJS(properties));
+      return this.setProperties(state, layerID, lineID, (0, _immutable.fromJS)(properties));
     }
   }, {
     key: "updateProperties",
@@ -1088,7 +1097,7 @@ var Line = /*#__PURE__*/function () {
   }, {
     key: "updateJsProperties",
     value: function updateJsProperties(state, layerID, lineID, properties) {
-      return this.updateProperties(state, layerID, lineID, fromJS(properties));
+      return this.updateProperties(state, layerID, lineID, (0, _immutable.fromJS)(properties));
     }
   }, {
     key: "setAttributes",
@@ -1107,17 +1116,17 @@ var Line = /*#__PURE__*/function () {
       delete lAttr['lineToExtend'];
       delete lAttr['lineLength'];
       var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
-      state = state.mergeIn(['scene', 'layers', layerID, 'lines', lineID], fromJS(lAttr)).mergeIn(['scene', 'layers', layerID, 'vertices', vertexOne.id], {
+      state = state.mergeIn(['scene', 'layers', layerID, 'lines', lineID], (0, _immutable.fromJS)(lAttr)).mergeIn(['scene', 'layers', layerID, 'vertices', vertexOne.id], {
         x: vertexOne.x,
         y: vertexOne.y
       }).mergeIn(['scene', 'layers', layerID, 'vertices', vertexTwo.id], {
         x: vertexTwo.x,
         y: vertexTwo.y
-      }).mergeIn(['scene', 'layers', layerID, 'lines', lineID, 'misc'], new Map({
+      }).mergeIn(['scene', 'layers', layerID, 'lines', lineID, 'misc'], new _immutable.Map({
         _unitLength: lineLength._unit
       })).mergeIn(['scene', 'layers', layerID, 'lines', lineID, 'focus'], true);
       if (lineToExtend) {
-        state = state.mergeIn(['scene', 'layers', layerID, 'lines', lineToExtend.id], fromJS(lAttr)).mergeIn(['scene', 'layers', layerID, 'lines', lineToExtend.id, 'misc'], new Map({
+        state = state.mergeIn(['scene', 'layers', layerID, 'lines', lineToExtend.id], (0, _immutable.fromJS)(lAttr)).mergeIn(['scene', 'layers', layerID, 'lines', lineToExtend.id, 'misc'], new _immutable.Map({
           _unitLength: lineLength._unit
         }));
       }
@@ -1133,14 +1142,14 @@ var Line = /*#__PURE__*/function () {
           y: vertexFour.y
         });
       }
-      state = Layer.mergeEqualsVertices(state, layerID, vertexOne.id).updatedState;
+      state = _export.Layer.mergeEqualsVertices(state, layerID, vertexOne.id).updatedState;
       if (vertexOne.x != vertexTwo.x && vertexOne.y != vertexTwo.y) {
-        state = Layer.mergeEqualsVertices(state, layerID, vertexTwo.id).updatedState;
+        state = _export.Layer.mergeEqualsVertices(state, layerID, vertexTwo.id).updatedState;
       }
       state = this.select(state, layerID, lineID).updatedState;
-      state = this.applyWallChanges(state, END_DRAWING_LINE).updatedState;
+      state = this.applyWallChanges(state, _constants.END_DRAWING_LINE).updatedState;
       state = state.merge({
-        sceneHistory: history.historyPush(state.sceneHistory, state.scene)
+        sceneHistory: _export2.history.historyPush(state.sceneHistory, state.scene)
       });
       if (state.mode.endsWith('_LINE')) {
         state = state.setIn(['scene', 'setLineAttributes'], true);
@@ -1154,11 +1163,11 @@ var Line = /*#__PURE__*/function () {
     key: "setVerticesCoords",
     value: function setVerticesCoords(state, layerID, lineID, x1, y1, x2, y2) {
       var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
-      state = Vertex.setAttributes(state, layerID, line.vertices.get(0), new Map({
+      state = _export.Vertex.setAttributes(state, layerID, line.vertices.get(0), new _immutable.Map({
         x: x1,
         y: y1
       })).updatedState;
-      state = Vertex.setAttributes(state, layerID, line.vertices.get(1), new Map({
+      state = _export.Vertex.setAttributes(state, layerID, line.vertices.get(1), new _immutable.Map({
         x: x2,
         y: y2
       })).updatedState;
@@ -1167,5 +1176,4 @@ var Line = /*#__PURE__*/function () {
       };
     }
   }]);
-}();
-export { Line as default };
+}();