microboard-temp 0.5.96 → 0.5.97

package/dist/cjs/browser.js

@@ -36900,6 +36900,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 +36946,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

@@ -36900,6 +36900,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 +36946,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

@@ -39373,6 +39373,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 +39419,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

@@ -36745,6 +36745,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 +36791,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

@@ -36738,6 +36738,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 +36784,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

@@ -39206,6 +39206,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 +39252,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.97",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",