microboard-temp 0.5.89 → 0.5.91

package/dist/cjs/browser.js

@@ -36927,43 +36927,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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

@@ -36927,43 +36927,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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

@@ -39400,43 +39400,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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

@@ -36772,43 +36772,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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

@@ -36765,43 +36765,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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

@@ -39233,43 +39233,70 @@ function reconstructPath(node2) {
 function createHookWaypoints(startPoint, endPoint, startDir, endDir) {
   if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("111");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
     const midY = (startPoint.y + endPoint.y) / 2;
+    console.log("222");
+    console.log([new Point(startPoint.x, midY), new Point(endPoint.x, midY)]);
     return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
   }
   if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("333");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
     const midX = (startPoint.x + endPoint.x) / 2;
+    console.log("444");
+    console.log([new Point(midX, startPoint.y), new Point(midX, endPoint.y)]);
     return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
   }
   const dx = endPoint.x - startPoint.x;
   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 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 findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
+  const tempGridInfo = createGrid(start, end);
+  const startPoint = tempGridInfo.newStart || start;
+  const endPoint = tempGridInfo.newEnd || end;
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const hookWaypoints = createHookWaypoints(startPoint, endPoint, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const allWaypoints = [...hookWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const points = [finalStart, ...allWaypoints, finalEnd];
+  const uniquePoints = points.reduce((acc, p3) => {
+    if (!acc.some((existing) => existing.barelyEqual(p3))) {
+      acc.push(p3);
+    }
+    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.89",
+  "version": "0.5.91",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",