kitchen-simulator 4.4.6 → 5.0.0-new-api.1

package/es/utils/geometry.js

@@ -2132,8 +2132,6 @@ export function relationshipOfTwoOverlappedLines2(srcLine, destLine) {
       };
       var line0 = [p1, p2].sort(comparator);
       var line1 = [p3, p4].sort(comparator);
-      var isReversedSrcLineDirection = false;
-      if (line0[0].x === srcLine.x2 && line0[0].y === srcLine.y2) isReversedSrcLineDirection = true;
       var _sort3 = [line0, line1].sort(function (lineA, lineB) {
           return comparator(lineA[0], lineB[0]);
         }),
@@ -2141,101 +2139,305 @@ export function relationshipOfTwoOverlappedLines2(srcLine, destLine) {
         lineSX = _sort4[0],
         lineDX = _sort4[1];
       var isReversedSrcLineIdx = false;
-      if (lineSX[0].x === line0[0].x && lineSX[0].y === line0[0].y) isReversedSrcLineIdx = false;else if (lineSX[0].x === line1[0].x && lineSX[0].y === line1[0].y) isReversedSrcLineIdx = true;
-      var compare0 = comparator(lineSX[0], lineDX[0]);
+      if (lineSX[0].x === line0[0].x && lineSX[0].y === line0[0].y) isReversedSrcLineIdx = false; // SX=srcLine, DX=destLine
+      else if (lineSX[0].x === line1[0].x && lineSX[0].y === line1[0].y) isReversedSrcLineIdx = true; // DX=srcLine, SX=destLine
+
+      var compare0 = comparator(lineSX[0], lineDX[0]); // always <= 0
       var compare1 = comparator(lineSX[1], lineDX[0]);
       var compare2 = comparator(lineSX[1], lineDX[1]);
-      if (MathUtils.fAbs(compare0) < EPSILON && MathUtils.fAbs(compare2) < EPSILON) {
-        return {
-          result: OVERLAP_SAME
-        };
-      } else if (MathUtils.fAbs(compare0) < EPSILON && compare2 < 0) {
-        // lineDX includes lineSX
-        if (!isReversedSrcLineIdx) {
-          // dest === lineDX : dest includes src
-          // return OVERLAP_INCLUDED; // lineSX[1] - lineDX[1]
-          return {
-            result: OVERLAP_INCLUDED
+      var sp = null,
+        ep = null;
+      if (MathUtils.fAbs(compare1) < EPSILON) {
+        //       SX
+        //  |----------|
+        //                   DX
+        //             |------------|
+        // link : lineSX[0] - lineDX[1]
+        if (lineSX[0].x === p1.x && lineSX[0].y === p1.y || lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+          sp = {
+            x: lineSX[0].x,
+            y: lineSX[0].y
+          };
+          ep = {
+            x: lineDX[1].x,
+            y: lineDX[1].y
+          };
+        } else {
+          // srcLine Direction is reversed
+          sp = {
+            x: lineDX[1].x,
+            y: lineDX[1].y
+          };
+          ep = {
+            x: lineSX[0].x,
+            y: lineSX[0].y
           };
         }
-        //  else {
-        //   // src includes dest
-        //   // return OVERLAP_SOME; // lineSX[1] - lineDX[1]
-        //   return {
-        //     result: OVERLAP_SOME,
-        //     trimmedSegs: {
-        //       x1: lineSX[1].x,
-        //       y1: lineSX[1].y,
-        //       x2: lineDX[1].x,
-        //       y2: lineDX[1].y
-        //     }
-        //   };
-        // }
-      }
-      if (MathUtils.fAbs(compare1) < EPSILON) {
-        // return OVERLAP_LINK; // lineSX[1]
         return {
           result: OVERLAP_LINK,
           linkedLine: {
-            x1: isReversedSrcLineDirection ? lineDX[1].x : lineSX[0].x,
-            y1: isReversedSrcLineDirection ? lineDX[1].y : lineSX[0].y,
-            x2: isReversedSrcLineDirection ? lineSX[0].x : lineDX[1].x,
-            y2: isReversedSrcLineDirection ? lineSX[0].y : lineDX[1].y
+            x1: sp.x,
+            y1: sp.y,
+            x2: ep.x,
+            y2: ep.y
           }
         };
       } else if (compare1 < 0) {
+        //       SX
+        //  |----------|
+        //                     DX
+        //                |----------|
+        // none
         return {
           result: OVERLAP_NONE
         };
-      } else {
-        if (MathUtils.fAbs(compare2) < EPSILON || compare2 > 0) {
-          // lineSX includes lineDX
-          if (isReversedSrcLineIdx) {
-            // dest === lineSX : dest includes src
-            // return OVERLAP_INCLUDED; // lineDX[0] - lineDX[1]
+      } else if (MathUtils.fAbs(compare0) < EPSILON && MathUtils.fAbs(compare2) < EPSILON) {
+        //       SX
+        //  |----------|
+        //       DX
+        //  |----------|
+        return {
+          result: OVERLAP_SAME
+        };
+      } else if (MathUtils.fAbs(compare0) < EPSILON) {
+        if (compare2 < 0 && isReversedSrcLineIdx) {
+          //       SX
+          //  |---------------|
+          //             DX
+          //  |-----------------------|
+          // DX includes SX, DX=srcLine, SX=destLine : sx1 - dx1
+          if (lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          } else {
+            // srcLine Direction is reversed
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          }
+          return {
+            result: OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else if (compare2 > 0 && !isReversedSrcLineIdx) {
+          //             SX
+          //  |-----------------------|
+          //         DX
+          //  |---------------|
+          // SX includes DX, SX=srcLine, DX=destLine  : dx1 - sx1
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          } else {
+            // srcLine Direction is reversed
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          }
+          return {
+            result: OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else {
+          //       srcLine
+          //  |---------------|
+          //          destLine
+          //  |-----------------------|
+          // destLine includes srcLine
+          return {
+            result: OVERLAP_INCLUDED
+          };
+        }
+      } else if (MathUtils.fAbs(compare2) < EPSILON) {
+        //             SX
+        //  |-----------------------|
+        //                DX
+        //       |------------------|
+        if (isReversedSrcLineIdx) {
+          // SX includes DX, DX=srcLine, SX=destLine
+          // destLine includes srcLine
+          return {
+            result: OVERLAP_INCLUDED
+          };
+        } else {
+          // SX includes DX, SX=srcLine, DX=destLine
+          // srcLine incluedes destLine : sx0 - dx0
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+            ep = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+            ep = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+          }
+          return {
+            result: OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        }
+      } else if (compare0 < 0 && compare2 > 0) {
+        //             SX
+        //  |-----------------------|
+        //             DX
+        //     |----------------|
+        if (isReversedSrcLineIdx) {
+          // SX includes DX, DX=srcLine, SX=destLine
+          // destLine includes srcLine
+          return {
+            result: OVERLAP_INCLUDED
+          };
+        } else {
+          // SX includes DX, SX=srcLine, DX=destLine
+          // srcLine incluedes destLine : sx0 - dx0, dx1 - sx1
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
             return {
-              result: OVERLAP_INCLUDED
+              result: OVERLAP_SOME,
+              trimmedSegs: [{
+                x1: lineSX[0].x,
+                y1: lineSX[0].y,
+                x2: lineDX[0].x,
+                y2: lineDX[0].y
+              }, {
+                x1: lineDX[1].x,
+                y1: lineDX[1].y,
+                x2: lineSX[1].x,
+                y2: lineSX[1].y
+              }]
             };
           } else {
-            // dest === lineDX : src includes dest
-            var trimmedSegs = [];
-            // return OVERLAP_SOME; // lineSX[0] - lineDX[0], lineDX[1] - lineSX[1]
-            if (compare0 < 0) trimmedSegs.push({
-              x1: isReversedSrcLineDirection ? lineDX[0].x : lineSX[0].x,
-              y1: isReversedSrcLineDirection ? lineDX[0].y : lineSX[0].y,
-              x2: isReversedSrcLineDirection ? lineSX[0].x : lineDX[0].x,
-              y2: isReversedSrcLineDirection ? lineSX[0].y : lineDX[0].y
-            });
-            if (compare2 > 0) trimmedSegs.push({
-              x1: isReversedSrcLineDirection ? lineSX[1].x : lineDX[1].x,
-              y1: isReversedSrcLineDirection ? lineSX[1].y : lineDX[1].y,
-              x2: isReversedSrcLineDirection ? lineDX[1].x : lineSX[1].x,
-              y2: isReversedSrcLineDirection ? lineDX[1].y : lineSX[1].y
-            });
+            // srcLine direction is reversed
             return {
               result: OVERLAP_SOME,
-              trimmedSegs: trimmedSegs
+              trimmedSegs: [{
+                x1: lineDX[0].x,
+                y1: lineDX[0].y,
+                x2: lineSX[0].x,
+                y2: lineSX[0].y
+              }, {
+                x1: lineSX[1].x,
+                y1: lineSX[1].y,
+                x2: lineDX[1].x,
+                y2: lineDX[1].y
+              }]
             };
           }
         }
-        if (compare2 < 0) {
-          // return OVERLAP_SOME; // lineSX[0] - lineDX[0], lineSX[1] - lineDX[1]
-          var _trimmedSegs = [];
-          if (compare0 < 0 && !isReversedSrcLineIdx) _trimmedSegs.push({
-            x1: isReversedSrcLineDirection ? lineDX[0].x : lineSX[0].x,
-            y1: isReversedSrcLineDirection ? lineDX[0].y : lineSX[0].y,
-            x2: isReversedSrcLineDirection ? lineSX[0].x : lineDX[0].x,
-            y2: isReversedSrcLineDirection ? lineSX[0].y : lineDX[0].y
-          });
-          if (compare2 < 0 && isReversedSrcLineIdx) _trimmedSegs.push({
-            x1: isReversedSrcLineDirection ? lineDX[1].x : lineSX[1].x,
-            y1: isReversedSrcLineDirection ? lineDX[1].y : lineSX[1].y,
-            x2: isReversedSrcLineDirection ? lineSX[1].x : lineDX[1].x,
-            y2: isReversedSrcLineDirection ? lineSX[1].y : lineDX[1].y
-          });
+      } else if (compare2 < 0) {
+        //             SX
+        //  |-----------------------|
+        //                   DX
+        //     |----------------------------|
+        // overlap some
+        if (isReversedSrcLineIdx) {
+          // DX=srcLine, SX=destLine
+          if (lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          }
+          return {
+            result: OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else {
+          // SX=srcLine, DX=destLine
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+            ep = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+            ep = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+          }
           return {
             result: OVERLAP_SOME,
-            trimmedSegs: _trimmedSegs
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
           };
         }
       }

package/es/utils/history.js

@@ -1,4 +1,4 @@
-import { List, Map } from 'immutable';
+import { Map, List } from 'immutable';
 import diff from 'immutablediff';
 import patch from 'immutablepatch';
 export var historyPush = function historyPush(historyStructure, item) {
@@ -11,7 +11,7 @@ export var historyPush = function historyPush(historyStructure, item) {
       });
 
       // convert map to object of the [value] field
-      if (List.isList(toPush.get('diff')) && ((_toPush$get = toPush.get('diff')) === null || _toPush$get === void 0 ? void 0 : _toPush$get.size) > 1) {
+      if (List.isList(toPush.get('diff')) && ((_toPush$get = toPush.get('diff')) === null || _toPush$get === void 0 ? void 0 : _toPush$get.size) > 0) {
         for (var i = 0; i < toPush.get('diff').size; i++) {
           var mapValue = toPush.get('diff').get(i).get('value');
           if (Map.isMap(mapValue)) {