microboard-temp 0.5.91 → 0.5.93

package/dist/cjs/browser.js

@@ -36967,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;
@@ -36978,7 +37009,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -36986,11 +37020,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/cjs/index.js

@@ -36967,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;
@@ -36978,7 +37009,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -36986,11 +37020,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/cjs/node.js

@@ -39440,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;
@@ -39451,7 +39482,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -39459,11 +39493,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/browser.js

@@ -36812,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;
@@ -36823,7 +36854,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -36831,11 +36865,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/index.js

@@ -36805,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;
@@ -36816,7 +36847,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -36824,11 +36858,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/dist/esm/node.js

@@ -39273,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;
@@ -39284,7 +39315,10 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  const points = [finalStart, ...allWaypoints, finalEnd];
+  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);
@@ -39292,11 +39326,6 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
     return acc;
   }, []);
   const pathPoints = findPathPoints(uniquePoints, grid, obstacles, newStart, newEnd);
-  console.log("RESULT", {
-    lines: getLines(pathPoints),
-    newStart,
-    newEnd
-  });
   return {
     lines: getLines(pathPoints),
     newStart,

package/package.json

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