kitchen-simulator 11.0.0-react.18 → 11.1.0

package/es/utils/geometry.js

@@ -719,6 +719,7 @@ export function getAllItems(scene, catalog, allLineRects) {
 }
 export function getAllItemSpecified(scene, catalog, filter) {
   var _scene$layers, _scene$layers$get;
+  var snappedLineRect = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
   var layerID = scene === null || scene === void 0 ? void 0 : scene.selectedLayer;
   var layer = scene === null || scene === void 0 || (_scene$layers = scene.layers) === null || _scene$layers === void 0 || (_scene$layers$get = _scene$layers.get) === null || _scene$layers$get === void 0 ? void 0 : _scene$layers$get.call(_scene$layers, layerID);
   if (!layer || !layer.items) return {
@@ -738,7 +739,8 @@ export function getAllItemSpecified(scene, catalog, filter) {
       rotRad: item.rotation / 180 * Math.PI
     };
     var cat = item.type ? findCatalogElement(catalog, item.type) : null;
-    var info = cat === null || cat === void 0 ? void 0 : cat.info;
+    val.layoutpos = item.layoutpos;
+    val.is_corner = item.is_corner;
     var props = item.properties;
     var getSize = function getSize(key) {
       var _props$getIn, _props$getIn2, _props$getIn3;
@@ -751,20 +753,49 @@ export function getAllItemSpecified(scene, catalog, filter) {
       depth: getSize('depth')
     };
     val.item = item;
-    if (info) {
-      val.layoutpos = info.layoutpos;
-      val.is_corner = info.is_corner;
-    }
 
     // Filter check
     if (Array.isArray(filter)) {
-      if (info && !filter.includes(info.layoutpos)) return;
-    } else if ((info === null || info === void 0 ? void 0 : info.layoutpos) !== filter || isEmpty(cat) || (cat === null || cat === void 0 ? void 0 : cat.type) === 'appliance' && ['Cook Top', 'Microwave'].includes(cat === null || cat === void 0 || (_cat$obj = cat.obj) === null || _cat$obj === void 0 ? void 0 : _cat$obj.category)) {
+      if (!val.layoutpos || !filter.includes(val.layoutpos)) return;
+    } else if (val.layoutpos !== filter || isEmpty(cat) || (cat === null || cat === void 0 ? void 0 : cat.type) === 'appliance' && ['Cook Top', 'Microwave'].includes(cat === null || cat === void 0 || (_cat$obj = cat.obj) === null || _cat$obj === void 0 ? void 0 : _cat$obj.category)) {
       return;
     }
 
     // Current vs others
     var rect = getCalcRectFromItem3D(val);
+
+    // check current item is snapped to the [snappedLineRect]
+    if (!isEmpty(snappedLineRect)) {
+      var isSnapped = false;
+      var overlapList = [OVERLAP_INCLUDED, OVERLAP_SAME, OVERLAP_SOME];
+      for (var i = 0; i < (rect === null || rect === void 0 || (_rect$rect = rect.rect) === null || _rect$rect === void 0 ? void 0 : _rect$rect.length); i++) {
+        var _rect$rect;
+        if (isSnapped) break;
+        var curItemPt = rect.rect[i];
+        var nextItemPt = i === rect.rect.length - 1 ? rect.rect[0] : rect.rect[i + 1];
+        var srcLine = {
+          x1: curItemPt.x,
+          y1: curItemPt.y,
+          x2: nextItemPt.x,
+          y2: nextItemPt.y
+        };
+        for (var j = 0; j < (snappedLineRect === null || snappedLineRect === void 0 ? void 0 : snappedLineRect.length); j++) {
+          var curLineRectPt = snappedLineRect[j];
+          var nextLineRectPt = j === snappedLineRect.length - 1 ? snappedLineRect[0] : snappedLineRect[j + 1];
+          var destLine = {
+            x1: curLineRectPt.x,
+            y1: curLineRectPt.y,
+            x2: nextLineRectPt.x,
+            y2: nextLineRectPt.y
+          };
+          if (overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine).result)) {
+            isSnapped = true;
+            break;
+          }
+        }
+      }
+      if (!isSnapped) return;
+    }
     if (item.selected) {
       curiteminfo = rect;
     } else {
@@ -2098,8 +2129,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]);
         }),
@@ -2107,101 +2136,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
+            }]
           };
         }
       }
@@ -2621,18 +2854,23 @@ export function calcDistancesFromHoleToNearestOneOrWall(curHole, layer) {
   var line = (_layer$lines = layer.lines) === null || _layer$lines === void 0 ? void 0 : _layer$lines.get(curHole.line);
   var v0 = (_layer$vertices2 = layer.vertices) === null || _layer$vertices2 === void 0 ? void 0 : _layer$vertices2.get(line === null || line === void 0 || (_line$vertices = line.vertices) === null || _line$vertices === void 0 ? void 0 : _line$vertices.get(0));
   var v1 = (_layer$vertices3 = layer.vertices) === null || _layer$vertices3 === void 0 ? void 0 : _layer$vertices3.get(line === null || line === void 0 || (_line$vertices2 = line.vertices) === null || _line$vertices2 === void 0 ? void 0 : _line$vertices2.get(1));
+  var lineLength = pointsDistance(v0.x, v0.y, v1.x, v1.y);
   if (isEmpty(line) || isEmpty(v0) || isEmpty(v1)) return distArray;
   var angle = angleBetweenTwoPoints(v0.x, v0.y, v1.x, v1.y);
 
   // start point and end point of current hole
   var chw = (_curHole$properties$g = (_curHole$properties = curHole.properties) === null || _curHole$properties === void 0 || (_curHole$properties = _curHole$properties.get('width')) === null || _curHole$properties === void 0 ? void 0 : _curHole$properties.get('length')) !== null && _curHole$properties$g !== void 0 ? _curHole$properties$g : 0;
+  var chPt = {
+    x: v0.x + lineLength * curHole.offset * Math.cos(angle),
+    y: v0.y + lineLength * curHole.offset * Math.sin(angle)
+  };
   var chsp = {
-    x: curHole.x - chw / 2 * Math.cos(angle),
-    y: curHole.y - chw / 2 * Math.sin(angle)
+    x: chPt.x - chw / 2 * Math.cos(angle),
+    y: chPt.y - chw / 2 * Math.sin(angle)
   };
   var chep = {
-    x: curHole.x + chw / 2 * Math.cos(angle),
-    y: curHole.y + chw / 2 * Math.sin(angle)
+    x: chPt.x + chw / 2 * Math.cos(angle),
+    y: chPt.y + chw / 2 * Math.sin(angle)
   };
   distArray.distLeft = pointsDistance(v0.x, v0.y, chsp.x, chsp.y);
   distArray.distRight = pointsDistance(v1.x, v1.y, chep.x, chep.y);
@@ -2642,13 +2880,17 @@ export function calcDistancesFromHoleToNearestOneOrWall(curHole, layer) {
       var hole = (_layer$holes = layer.holes) === null || _layer$holes === void 0 ? void 0 : _layer$holes.get(hId);
       // start point and end point of other hole
       var hw = (_hole$properties$get$ = (_hole$properties = hole.properties) === null || _hole$properties === void 0 || (_hole$properties = _hole$properties.get('width')) === null || _hole$properties === void 0 ? void 0 : _hole$properties.get('length')) !== null && _hole$properties$get$ !== void 0 ? _hole$properties$get$ : 0;
+      var hPt = {
+        x: v0.x + lineLength * hole.offset * Math.cos(angle),
+        y: v0.y + lineLength * hole.offset * Math.sin(angle)
+      };
       var hsp = {
-        x: hole.x - hw / 2 * Math.cos(angle),
-        y: hole.y - hw / 2 * Math.sin(angle)
+        x: hPt.x - hw / 2 * Math.cos(angle),
+        y: hPt.y - hw / 2 * Math.sin(angle)
       };
       var hep = {
-        x: hole.x + hw / 2 * Math.cos(angle),
-        y: hole.y + hw / 2 * Math.sin(angle)
+        x: hPt.x + hw / 2 * Math.cos(angle),
+        y: hPt.y + hw / 2 * Math.sin(angle)
       };
       var relation = relationshipOfTwoOverlappedLines({
         x1: chsp.x,
@@ -2734,15 +2976,15 @@ export function getSnappedWallLines(item, layer, catalog) {
       var _loop2 = function _loop2(j) {
         var destLine1 = {
           x1: rectLines[j].rect[2].x,
-          y1: rectLines[j].rect[3].y,
-          x2: v1.x,
-          y2: v1.y
+          y1: rectLines[j].rect[2].y,
+          x2: rectLines[j].rect[3].x,
+          y2: rectLines[j].rect[3].y
         };
         var destLine2 = {
           x1: rectLines[j].rect[0].x,
-          y1: rectLines[j].rect[1].y,
-          x2: v1.x,
-          y2: v1.y
+          y1: rectLines[j].rect[0].y,
+          x2: rectLines[j].rect[1].x,
+          y2: rectLines[j].rect[1].y
         };
         if (overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine1).result) || overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine2).result)) {
           var idx = snappedWallLines.findIndex(function (v) {
@@ -2751,6 +2993,7 @@ export function getSnappedWallLines(item, layer, catalog) {
           var snapSide = 'unknown';
           if (idx < 0) snappedWallLines.push({
             id: rectLines[j].lineId,
+            lineRect: rectLines[j].rect,
             snapSide: snapSide
           });else snappedWallLines[idx].snapSide = snapSide;
         }
@@ -2790,6 +3033,7 @@ export function getSnappedWallLines(item, layer, catalog) {
           var snapSide = _i === 0 || _i === 2 ? 'front' : 'side';
           if (idx < 0) snappedWallLines.push({
             id: rectLines[_j].lineId,
+            lineRect: rectLines[_j].rect,
             snapSide: snapSide
           });else snappedWallLines[idx].snapSide = snapSide;
         }
@@ -2800,4 +3044,83 @@ export function getSnappedWallLines(item, layer, catalog) {
     }
   }
   return snappedWallLines;
+}
+export function getLineSnapPointsOfItem(layer, curLine, item) {
+  var _layer$lines2, _layer$vertices4, _line$vertices3, _layer$vertices5, _line$vertices4;
+  //       V0
+  //       /|
+  //    D0 /|-----------|
+  //       /|           |
+  //       /|    Item   |    ====>   get D0, D1
+  //       /|           |
+  //    D1 /|-----------|
+  //       /|
+  // get v0, v1 of line
+  var line = (_layer$lines2 = layer.lines) === null || _layer$lines2 === void 0 ? void 0 : _layer$lines2.get(curLine === null || curLine === void 0 ? void 0 : curLine.id);
+  var v0 = (_layer$vertices4 = layer.vertices) === null || _layer$vertices4 === void 0 ? void 0 : _layer$vertices4.get(line === null || line === void 0 || (_line$vertices3 = line.vertices) === null || _line$vertices3 === void 0 ? void 0 : _line$vertices3.get(0));
+  var v1 = (_layer$vertices5 = layer.vertices) === null || _layer$vertices5 === void 0 ? void 0 : _layer$vertices5.get(line === null || line === void 0 || (_line$vertices4 = line.vertices) === null || _line$vertices4 === void 0 ? void 0 : _line$vertices4.get(1));
+  var pointGroup = [];
+  if (isEmpty(v0) || isEmpty(v1)) return pointGroup;
+  var itemRect = item === null || item === void 0 ? void 0 : item.rect;
+  if (!isEmpty(itemRect)) {
+    for (var i = 0; i < itemRect.length; i++) {
+      if (distancePointFromLineSegment(v0, v1, itemRect[i].x, itemRect[i].y) < EPSILON) {
+        pointGroup.push(itemRect[i]);
+      }
+    }
+  }
+  return pointGroup;
+}
+export function isOverlappedTwoItemsOnOneLine(layer, curLine, srcItem, desItem) {
+  var _layer$lines3, _layer$vertices6, _line$vertices5, _layer$vertices7, _line$vertices6, _S, _S2, _S3, _S4;
+  if (isEmpty(layer) || isEmpty(curLine) || isEmpty(srcItem) || isEmpty(desItem) || isEmpty(desItem.D0) || isEmpty(desItem.D1)) return false;
+  // get v0, v1 of line
+  var line = (_layer$lines3 = layer.lines) === null || _layer$lines3 === void 0 ? void 0 : _layer$lines3.get(curLine === null || curLine === void 0 ? void 0 : curLine.id);
+  var v0 = (_layer$vertices6 = layer.vertices) === null || _layer$vertices6 === void 0 ? void 0 : _layer$vertices6.get(line === null || line === void 0 || (_line$vertices5 = line.vertices) === null || _line$vertices5 === void 0 ? void 0 : _line$vertices5.get(0));
+  var v1 = (_layer$vertices7 = layer.vertices) === null || _layer$vertices7 === void 0 ? void 0 : _layer$vertices7.get(line === null || line === void 0 || (_line$vertices6 = line.vertices) === null || _line$vertices6 === void 0 ? void 0 : _line$vertices6.get(1));
+  var S0,
+    S1,
+    D0 = desItem === null || desItem === void 0 ? void 0 : desItem.D0,
+    D1 = desItem === null || desItem === void 0 ? void 0 : desItem.D1;
+  if (isEmpty(v0) || isEmpty(v1)) return false;
+  // get distance from v0 to srcItem's S0, S1 and desItem(item or hole)'s D0, D1 are placed on line
+  var srcPoints = getLineSnapPointsOfItem(layer, curLine, srcItem);
+  if (srcPoints.length > 1) {
+    S0 = srcPoints[0];
+    S1 = srcPoints[1];
+  }
+  var disV0S0 = pointsDistance(v0.x, v0.y, (_S = S0) === null || _S === void 0 ? void 0 : _S.x, (_S2 = S0) === null || _S2 === void 0 ? void 0 : _S2.y);
+  var disV0S1 = pointsDistance(v0.x, v0.y, (_S3 = S1) === null || _S3 === void 0 ? void 0 : _S3.x, (_S4 = S1) === null || _S4 === void 0 ? void 0 : _S4.y);
+  var disV0D0 = pointsDistance(v0.x, v0.y, D0.x, D0.y);
+  var disV0D1 = pointsDistance(v0.x, v0.y, D1.x, D1.y);
+  // detect two items are overlapped
+  var maxDisV0S = Math.max(disV0S0, disV0S1);
+  var minDisV0S = Math.min(disV0S0, disV0S1);
+  var maxDisV0D = Math.max(disV0D0, disV0D1);
+  var minDisV0D = Math.min(disV0D0, disV0D1);
+  if (maxDisV0S > maxDisV0D && maxDisV0D - minDisV0S > EPSILON) {
+    //      d0     s0 d1  s1   ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |  |   |
+    //      |      |  |   |
+    //      |__DI__|__|   |
+    //             |__SI__|
+    /////////////////////////////////////////
+    //      s0     d0     d1   s1  ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |      |    |
+    //      |      |__DI__|    |
+    //      |_________SI_______|
+    return true;
+  } else if (minDisV0S < minDisV0D && maxDisV0S - minDisV0D > EPSILON) {
+    //      s0     d0 s1  d1   ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |  |   |
+    //      |      |__DI__|
+    //      |__SI_____|
+    //
+    return true;
+  } else {
+    return false;
+  }
 }