kitchen-simulator 7.0.9-react-18 → 10.0.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 {
@@ -759,12 +760,45 @@ export function getAllItemSpecified(scene, catalog, filter) {
     // Filter check
     if (Array.isArray(filter)) {
       if (info && !filter.includes(info.layoutpos)) return;
-    } else if (info && (info.layoutpos !== filter || (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))) {
+    } 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)) {
       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 {
@@ -995,9 +1029,9 @@ export function getAllLines(layer) {
           }
         }
       });
-      allLines.splice(addIdx, 0, [vertices, thick]);
+      allLines.splice(addIdx, 0, [vertices, thick, line.id]);
     } else {
-      allLines.push([allAreaLines[i], thick]);
+      allLines.push([allAreaLines[i], thick, line.id]);
     }
   });
   return allLines;
@@ -1039,7 +1073,9 @@ export function buildRectFromLines(layer, lines) {
     var y0 = vxys[1];
     var x1 = vxys[2];
     var y1 = vxys[3];
-    rect.push(getCalcRectFromLine(x0, y0, x1, y1, thick, layer));
+    var rectLine = getCalcRectFromLine(x0, y0, x1, y1, thick, layer);
+    rectLine.lineId = line.length > 2 ? line[2] : null;
+    rect.push(rectLine);
   });
   return rect;
 }
@@ -2096,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]);
         }),
@@ -2105,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
+            }]
           };
         }
       }
@@ -2606,4 +2844,286 @@ export function calcDistancesFromItemToWalls(curItem, layer) {
   return {
     PointArray: PointArray
   };
+}
+export function calcDistancesFromHoleToNearestOneOrWall(curHole, layer) {
+  var _layer$lines, _layer$vertices2, _line$vertices, _layer$vertices3, _line$vertices2, _curHole$properties$g, _curHole$properties, _line$get;
+  var distArray = {
+    distLeft: 0,
+    distRight: 0
+  };
+  if (isEmpty(curHole)) return distArray;
+  /***** calculate Left & Right distance from nearest hole ******/
+  // parent line of curHole
+  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: chPt.x - chw / 2 * Math.cos(angle),
+    y: chPt.y - chw / 2 * Math.sin(angle)
+  };
+  var chep = {
+    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);
+  (_line$get = line.get('holes')) === null || _line$get === void 0 || _line$get.forEach(function (hId) {
+    if (hId !== curHole.id) {
+      var _layer$holes, _hole$properties$get$, _hole$properties;
+      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: hPt.x - hw / 2 * Math.cos(angle),
+        y: hPt.y - hw / 2 * Math.sin(angle)
+      };
+      var hep = {
+        x: hPt.x + hw / 2 * Math.cos(angle),
+        y: hPt.y + hw / 2 * Math.sin(angle)
+      };
+      var relation = relationshipOfTwoOverlappedLines({
+        x1: chsp.x,
+        y1: chsp.y,
+        x2: chep.x,
+        y2: chep.y
+      }, {
+        x1: hsp.x,
+        y1: hsp.y,
+        x2: hep.x,
+        y2: hep.y
+      });
+      // two holes(current hole and other hole) are not overlaped, then get distance
+      if (relation.result === OVERLAP_NONE || relation.result === OVERLAP_LINK) {
+        if (hole.offset < curHole.offset)
+          // other hole is on the left side
+          distArray.distLeft = Math.min(distArray.distLeft, pointsDistance(chsp.x, chsp.y, hep.x, hep.y));
+          // other hole is on the right side
+        else distArray.distRight = Math.min(distArray.distRight, pointsDistance(chep.x, chep.y, hsp.x, hsp.y));
+      }
+    }
+  });
+  return distArray;
+}
+export function getSnappedWallLines(item, layer, catalog) {
+  var _element;
+  var snappedWallLines = [];
+  if (isEmpty(item)) return snappedWallLines;
+  var vertexLines = getAllLines(layer);
+  var rectLines = buildRectFromLines(layer, vertexLines);
+  var outline = null;
+  var element = catalog.elements[item.get('type')];
+  if (!element) element = catalog.elements[returnReplaceableDeepSearchType(item.get('type'))];
+  var newWidth = item.properties.get('width').get('_length');
+  var wUnit = item.properties.get('width').get('_unit') || 'cm';
+  newWidth = convert(newWidth).from(wUnit).to('cm');
+  var newDepth = item.properties.get('depth').get('_length');
+  var hUnit = item.properties.get('depth').get('_unit') || 'cm';
+  newDepth = convert(newDepth).from(hUnit).to('cm');
+  var overlapList = [OVERLAP_INCLUDED, OVERLAP_SAME, OVERLAP_SOME];
+
+  // Get Outline Data of Selected Item
+  outline = (_element = element) === null || _element === void 0 || (_element = _element.info) === null || _element === void 0 ? void 0 : _element.outline;
+  if (outline) {
+    // Extract Points from `outline`
+    var outlinePaths = outline.paths;
+    var outlineWidth = outline.svgWidth;
+    var outlineHeight = outline.svgHeight;
+    var outlinePoints = []; // Hold Points Of SVG
+    var _iterator7 = _createForOfIteratorHelper(outlinePaths),
+      _step7;
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        var path = _step7.value;
+        var _iterator8 = _createForOfIteratorHelper(path.subPaths),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var subPath = _step8.value;
+            outlinePoints = outlinePoints.concat(subPath.getPoints());
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+    outline.reverse && outlinePoints.reverse();
+    for (var i = 0; i < outlinePoints.length - 1; i++) {
+      var v0 = rotatePointAroundPoint((outlinePoints[i].x / outlineWidth - 0.5) * newWidth + item.x, (outlinePoints[i].y / outlineHeight - 0.5) * newDepth + item.y, item.x, item.y, item.rotation + 90);
+      var v1 = rotatePointAroundPoint((outlinePoints[i + 1].x / outlineWidth - 0.5) * newWidth + item.x, (outlinePoints[i + 1].y / outlineHeight - 0.5) * newDepth + item.y, item.x, item.y, item.rotation + 90);
+      var srcLine = {
+        x1: v0.x,
+        y1: v0.y,
+        x2: v1.x,
+        y2: v1.y
+      };
+      var _loop2 = function _loop2(j) {
+        var destLine1 = {
+          x1: rectLines[j].rect[2].x,
+          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[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) {
+            return v.id === rectLines[j].lineId;
+          });
+          var snapSide = 'unknown';
+          if (idx < 0) snappedWallLines.push({
+            id: rectLines[j].lineId,
+            lineRect: rectLines[j].rect,
+            snapSide: snapSide
+          });else snappedWallLines[idx].snapSide = snapSide;
+        }
+      };
+      for (var j = 0; j < (rectLines === null || rectLines === void 0 ? void 0 : rectLines.length); j++) {
+        _loop2(j);
+      }
+    }
+  } else {
+    var pos = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+    for (var _i = 0; _i < 4; _i++) {
+      var _v = rotatePointAroundPoint(pos[_i][0] * newWidth / 2 + item.x, pos[_i][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation);
+      var _v2 = rotatePointAroundPoint(pos[(_i + 1) % 4][0] * newWidth / 2 + item.x, pos[(_i + 1) % 4][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation);
+      var _srcLine = {
+        x1: _v.x,
+        y1: _v.y,
+        x2: _v2.x,
+        y2: _v2.y
+      };
+      var _loop3 = function _loop3(_j) {
+        var destLine1 = {
+          x1: rectLines[_j].rect[2].x,
+          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[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) {
+            return v.id === rectLines[_j].lineId;
+          });
+          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;
+        }
+      };
+      for (var _j = 0; _j < (rectLines === null || rectLines === void 0 ? void 0 : rectLines.length); _j++) {
+        _loop3(_j);
+      }
+    }
+  }
+  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;
+  }
 }