microboard-temp 0.5.83 → 0.5.85

package/dist/cjs/browser.js

@@ -36731,45 +36731,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36929,77 +36934,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/dist/cjs/index.js

@@ -36731,45 +36731,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36929,77 +36934,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/dist/cjs/node.js

@@ -39204,45 +39204,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -39402,77 +39407,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/dist/esm/browser.js

@@ -36576,45 +36576,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36774,77 +36779,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/dist/esm/index.js

@@ -36569,45 +36569,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36767,77 +36772,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/dist/esm/node.js

@@ -39037,45 +39037,50 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -offset },
-    bottom: { x: 0, y: offset },
-    right: { x: offset, y: 0 },
-    left: { x: -offset, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
+  let newStart;
+  let newEnd;
   const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return;
     const itemMbr = point5.item.getMbr();
-    const pointOnMbrX = point5.x - offsetMap[dir2].x;
-    const pointOnMbrY = point5.y - offsetMap[dir2].y;
-    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
-    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
+    return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
-    processPoint(start, startDir);
+    newStart = processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    processPoint(end, endDir);
-  }
-  const allPoints = [start, end, ...toVisitPoints];
-  allPoints.forEach((p3) => {
+    newEnd = processPoint(end, endDir);
+  }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
-  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  horizontalLines.push(middle.y);
-  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart: start,
-    newEnd: end
+    newStart,
+    newEnd,
+    middlePoint: middle
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -39235,77 +39240,50 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
+function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
+  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
+    const midY = (startPoint.y + endPoint.y) / 2;
+    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
+  }
+  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
+    const midX = (startPoint.x + endPoint.x) / 2;
+    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
+  }
+  const dx = endPoint.x - startPoint.x;
+  const dy = endPoint.y - startPoint.y;
+  const startConflictX = startDir === "right" && dx < 0 || startDir === "left" && dx > 0;
+  const startConflictY = startDir === "bottom" && dy < 0 || startDir === "top" && dy > 0;
+  const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
+  const endConflictY = endDir === "bottom" && dy > 0 || endDir === "top" && dy < 0;
+  if (startConflictX || endConflictY) {
+    return [new Point(startPoint.x, endPoint.y)];
+  }
+  if (startConflictY || endConflictX) {
+    return [new Point(endPoint.x, startPoint.y)];
+  }
+  return [];
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
-  const offset = conf.CONNECTOR_ITEM_OFFSET;
-  let startPoint = start;
-  let endPoint = end;
-  const processPoint = (point5, dir2) => {
-    if (point5.pointType === "Board")
-      return point5;
-    const offsetMap = {
-      top: { x: 0, y: -offset },
-      bottom: { x: 0, y: offset },
-      right: { x: offset, y: 0 },
-      left: { x: -offset, y: 0 }
-    };
-    const itemMbr = point5.item.getMbr();
-    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
-    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
-    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
-    return newPoint;
-  };
-  if (start.pointType !== "Board" && startDir) {
-    startPoint = processPoint(start, startDir);
-  }
-  if (end.pointType !== "Board" && endDir) {
-    endPoint = processPoint(end, endDir);
-  }
-  const stemWaypoints = [];
-  if (startDir) {
-    let stem;
-    if (startDir === "right")
-      stem = new Point(startPoint.x + offset, startPoint.y);
-    else if (startDir === "left")
-      stem = new Point(startPoint.x - offset, startPoint.y);
-    else if (startDir === "bottom")
-      stem = new Point(startPoint.x, startPoint.y + offset);
-    else
-      stem = new Point(startPoint.x, startPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  if (endDir) {
-    let stem;
-    if (endDir === "right")
-      stem = new Point(endPoint.x + offset, endPoint.y);
-    else if (endDir === "left")
-      stem = new Point(endPoint.x - offset, endPoint.y);
-    else if (endDir === "bottom")
-      stem = new Point(endPoint.x, endPoint.y + offset);
-    else
-      stem = new Point(endPoint.x, endPoint.y - offset);
-    stemWaypoints.push(stem);
-  }
-  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
-  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
-  let finalWaypoints = [startPoint];
-  if (stemWaypoints.length > 0) {
-    finalWaypoints.push(stemWaypoints[0]);
-  }
-  finalWaypoints.push(...toVisitPoints);
-  if (stemWaypoints.length > 1) {
-    finalWaypoints.push(stemWaypoints[1]);
-  }
-  finalWaypoints.push(endPoint);
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
+  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart: startPoint,
-    newEnd: endPoint
+    newStart,
+    newEnd
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "microboard-temp",
-  "version": "0.5.83",
+  "version": "0.5.85",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",