microboard-temp 0.5.92 → 0.5.93

package/dist/cjs/browser.js

@@ -36924,20 +36924,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -36981,6 +36967,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -36992,15 +37009,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/cjs/index.js

@@ -36924,20 +36924,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -36981,6 +36967,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -36992,15 +37009,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/cjs/node.js

@@ -39397,20 +39397,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -39454,6 +39440,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -39465,15 +39482,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/browser.js

@@ -36769,20 +36769,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -36826,6 +36812,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -36837,15 +36854,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/index.js

@@ -36762,20 +36762,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -36819,6 +36805,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -36830,15 +36847,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/node.js

@@ -39230,20 +39230,6 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function findClosestPointInGrid(point5, grid) {
-  let closestPoint = grid[0][0];
-  let minDistance = Infinity;
-  for (const row2 of grid) {
-    for (const gridPoint of row2) {
-      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestPoint = gridPoint;
-      }
-    }
-  }
-  return closestPoint;
-}
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
@@ -39287,6 +39273,37 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+function findClosestPointInGrid(point5, grid) {
+  let closestPoint = grid[0][0];
+  let minDistance = Infinity;
+  for (const row2 of grid) {
+    for (const gridPoint of row2) {
+      const distance = Math.abs(point5.x - gridPoint.x) + Math.abs(point5.y - gridPoint.y);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestPoint = gridPoint;
+      }
+    }
+  }
+  return closestPoint;
+}
+function findClosestValidPointInGrid(point5, grid, obstacles) {
+  let closestPoint = null;
+  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;
+        }
+      }
+    }
+  }
+  return closestPoint;
+}
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const tempGridInfo = createGrid(start, end);
   const startPoint = tempGridInfo.newStart || start;
@@ -39298,15 +39315,17 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const pointsToVisit = [finalStart, ...allWaypoints, finalEnd];
-  const uniquePoints = pointsToVisit.reduce((acc, p3) => {
+  const snappedStart = findClosestPointInGrid(finalStart, grid);
+  const snappedEnd = findClosestPointInGrid(finalEnd, grid);
+  const snappedWaypoints = allWaypoints.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  const points = [snappedStart, ...snappedWaypoints, snappedEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
     if (!acc.some((existing) => existing.barelyEqual(p3))) {
       acc.push(p3);
     }
     return acc;
   }, []);
-  const snappedPoints = uniquePoints.map((p3) => findClosestPointInGrid(p3, grid));
-  const pathPoints = findPathPoints(snappedPoints, grid, obstacles, newStart, newEnd);
+  const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
     newStart,

package/package.json

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