microboard-temp 0.5.95 → 0.5.97

package/dist/cjs/browser.js

@@ -36848,30 +36848,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -36927,26 +36903,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -36956,59 +36924,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/cjs/index.js

@@ -36848,30 +36848,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -36927,26 +36903,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -36956,59 +36924,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/cjs/node.js

@@ -39321,30 +39321,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -39400,26 +39376,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -39429,59 +39397,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/browser.js

@@ -36693,30 +36693,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -36772,26 +36748,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -36801,59 +36769,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/index.js

@@ -36686,30 +36686,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -36765,26 +36741,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -36794,59 +36762,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/dist/esm/node.js

@@ -39154,30 +39154,6 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   }
   return;
 }
-function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  if (points.length < 2) {
-    return points;
-  }
-  const finalPath = [points[0]];
-  const existingPathSegments = new Set([`${points[0].x},${points[0].y}`]);
-  for (let i = 0;i < points.length - 1; i += 1) {
-    const startSegment = points[i];
-    const endSegment = points[i + 1];
-    const segmentPath = findPath(startSegment, endSegment, grid, obstacles, existingPathSegments, newStart, newEnd);
-    if (segmentPath && segmentPath.length > 0) {
-      for (let j = 1;j < segmentPath.length; j++) {
-        const point5 = segmentPath[j];
-        const key = `${point5.x},${point5.y}`;
-        finalPath.push(point5);
-        existingPathSegments.add(key);
-      }
-    } else {
-      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
-      return [];
-    }
-  }
-  return finalPath;
-}
 function reducePoints(points) {
   const uniquePoints = new Map;
   const result = [];
@@ -39233,26 +39209,18 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
-    console.log("111");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("222");
-    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     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;
-    console.log("333");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     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;
-    console.log("444");
-    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
@@ -39262,59 +39230,44 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   const endConflictX = endDir === "right" && dx > 0 || endDir === "left" && dx < 0;
   const endConflictY = endDir === "bottom" && dy < 0 || endDir === "top" && dy > 0;
   if (startConflictX || endConflictY) {
-    console.log("555");
-    console.log([new Point(startPoint.x, endPoint.y)]);
     return [new Point(startPoint.x, endPoint.y)];
   }
   if (startConflictY || endConflictX) {
-    console.log("666");
-    console.log([new Point(endPoint.x, startPoint.y)]);
     return [new Point(endPoint.x, startPoint.y)];
   }
   return [];
 }
-function findClosestValidPointInGrid(point5, grid, obstacles) {
-  let closestPoint = null;
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
   let minDistance = Infinity;
   for (const row2 of grid) {
     for (const gridPoint of row2) {
-      const isPointValid = !obstacles.some((obstacle) => obstacle.isAlmostInside(gridPoint, conf.CONNECTOR_ITEM_OFFSET - 1));
-      if (isPointValid) {
-        const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-        if (distance < minDistance) {
-          minDistance = distance;
-          closestPoint = gridPoint;
-        }
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
       }
     }
   }
   return closestPoint;
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const tempGridInfo = 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 allWaypoints = [...hookWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
-  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
-  if (snappedAndValidatedPoints.length < 2) {
+  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 uniquePoints = snappedAndValidatedPoints.reduce((acc, p3) => {
-    if (!acc.some((existing) => existing.barelyEqual(p3))) {
-      acc.push(p3);
-    }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  const searchStart = findClosestPointInGrid(newStart || start, grid);
+  const searchEnd = findClosestPointInGrid(newEnd || end, grid);
+  const pathPoints = findPath(searchStart, searchEnd, grid, obstacles, new Set, newStart, newEnd);
   return {
-    lines: getLines(pathPoints),
+    lines: pathPoints ? getLines(pathPoints) : [],
     newStart,
     newEnd
   };

package/package.json

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