microboard-temp 0.5.95 → 0.5.96

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 = [];
@@ -36924,91 +36900,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     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 = [];
@@ -36924,91 +36900,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     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 = [];
@@ -39397,91 +39373,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     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 = [];
@@ -36769,91 +36745,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     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 = [];
@@ -36762,91 +36738,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     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 = [];
@@ -39230,91 +39206,48 @@ 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;
-    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;
-  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) {
-    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 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 { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  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);
+  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 };
     }
-    return acc;
-  }, []);
-  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
+  }
   return {
-    lines: getLines(pathPoints),
+    lines: getLines(finalPath),
     newStart,
     newEnd
   };

package/package.json

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