microboard-temp 0.5.96 → 0.5.98

package/dist/cjs/browser.js

@@ -36682,6 +36682,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -36693,10 +36694,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -36900,6 +36904,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -36915,33 +36950,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/cjs/index.js

@@ -36682,6 +36682,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -36693,10 +36694,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -36900,6 +36904,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -36915,33 +36950,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/cjs/node.js

@@ -39155,6 +39155,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -39166,10 +39167,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -39373,6 +39377,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -39388,33 +39423,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/browser.js

@@ -36527,6 +36527,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -36538,10 +36539,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -36745,6 +36749,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -36760,33 +36795,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/index.js

@@ -36520,6 +36520,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -36531,10 +36532,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -36738,6 +36742,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -36753,33 +36788,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/node.js

@@ -38988,6 +38988,7 @@ function getDirection(from, to) {
   return null;
 }
 function isChangingDirection(current, neighbor, newStart, newEnd) {
+  const TURN_PENALTY = 50;
   const dirMap = {
     top: "vertical",
     bottom: "vertical",
@@ -38999,10 +39000,13 @@ function isChangingDirection(current, neighbor, newStart, newEnd) {
   if (newEnd && neighbor.point.barelyEqual(newEnd)) {
     const endDir = dirMap[getPointerDirection(newEnd)];
     if (goingDirection && endDir !== goingDirection) {
-      return 1 + isChangingDirection(current, neighbor, newStart);
+      return TURN_PENALTY;
     }
   }
-  return comingDirection && goingDirection && comingDirection !== goingDirection ? 1 : 0;
+  if (comingDirection && goingDirection && comingDirection !== goingDirection) {
+    return TURN_PENALTY;
+  }
+  return 0;
 }
 function heuristic(start, end) {
   return Math.abs(start.xGrid - end.xGrid) + Math.abs(start.yGrid - end.yGrid);
@@ -39206,6 +39210,37 @@ 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 findClosestPointInGrid(point5, grid) {
   let closestPoint = grid[0][0];
   let minDistance = Infinity;
@@ -39221,33 +39256,22 @@ function findClosestPointInGrid(point5, grid) {
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
+  const allGuidingPoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allGuidingPoints);
   if (grid.length === 0 || grid[0].length === 0) {
     return { lines: [], newStart, newEnd };
   }
   const searchStart = findClosestPointInGrid(newStart || start, grid);
   const searchEnd = findClosestPointInGrid(newEnd || end, grid);
-  const snappedWaypoints = toVisitPoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pointsToConnect = [searchStart, ...snappedWaypoints, searchEnd];
-  const finalPath = [pointsToConnect[0]];
-  const existingPathSegments = new Set([`${pointsToConnect[0].x},${pointsToConnect[0].y}`]);
-  for (let i = 0;i < pointsToConnect.length - 1; i++) {
-    const segmentStart = pointsToConnect[i];
-    const segmentEnd = pointsToConnect[i + 1];
-    const segmentPath = findPath(segmentStart, segmentEnd, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 1) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        finalPath.push(point5);
-        existingPathSegments.add(`${point5.x},${point5.y}`);
-      }
-    } else {
-      console.error(`Could not route segment from ${segmentStart.x},${segmentStart.y} to ${segmentEnd.x},${segmentEnd.y}`);
-      return { lines: [], newStart, newEnd };
-    }
-  }
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(finalPath),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/package.json

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