microboard-temp 0.5.92 → 0.5.94

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,8 +36967,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -36992,15 +36995,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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,8 +36967,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -36992,15 +36995,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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,8 +39440,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -39465,15 +39468,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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,8 +36812,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -36837,15 +36840,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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,8 +36805,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -36830,15 +36833,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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,8 +39273,25 @@ function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   }
   return [];
 }
+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 tempGridInfo = createGrid(start, end, toVisitPoints);
   const startPoint = tempGridInfo.newStart || start;
   const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
@@ -39298,15 +39301,18 @@ 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 pointsToSnap = [finalStart, ...allWaypoints, finalEnd];
+  const snappedAndValidatedPoints = pointsToSnap.map((p3) => findClosestValidPointInGrid(p3, grid, obstacles)).filter((p3) => p3 !== null);
+  if (snappedAndValidatedPoints.length < 2) {
+    return { lines: [], newStart, newEnd };
+  }
+  const uniquePoints = snappedAndValidatedPoints.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.94",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",