microboard-temp 0.5.93 → 0.5.95

package/dist/cjs/browser.js

@@ -36849,15 +36849,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -36866,8 +36866,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -36967,20 +36967,6 @@ 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;
@@ -36999,7 +36985,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -37009,11 +36995,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/dist/cjs/index.js

@@ -36849,15 +36849,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -36866,8 +36866,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -36967,20 +36967,6 @@ 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;
@@ -36999,7 +36985,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -37009,11 +36995,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/dist/cjs/node.js

@@ -39322,15 +39322,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -39339,8 +39339,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -39440,20 +39440,6 @@ 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;
@@ -39472,7 +39458,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -39482,11 +39468,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/dist/esm/browser.js

@@ -36694,15 +36694,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -36711,8 +36711,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -36812,20 +36812,6 @@ 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;
@@ -36844,7 +36830,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -36854,11 +36840,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/dist/esm/index.js

@@ -36687,15 +36687,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -36704,8 +36704,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -36805,20 +36805,6 @@ 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;
@@ -36837,7 +36823,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -36847,11 +36833,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/dist/esm/node.js

@@ -39155,15 +39155,15 @@ function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const finalPath = [];
-  const existingPathSegments = new Set;
-  if (points.length > 0) {
-    finalPath.push(points[0]);
-    const startKey = `${points[0].x},${points[0].y}`;
-    existingPathSegments.add(startKey);
+  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 segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    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];
@@ -39172,8 +39172,8 @@ function findPathPoints(points, grid, obstacles, newStart, newEnd) {
         existingPathSegments.add(key);
       }
     } else {
-      points.splice(i + 1, 1);
-      i--;
+      console.error(`Could not find path from ${startSegment.x},${startSegment.y} to ${endSegment.x},${endSegment.y}`);
+      return [];
     }
   }
   return finalPath;
@@ -39273,20 +39273,6 @@ 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;
@@ -39305,7 +39291,7 @@ function findClosestValidPointInGrid(point5, grid, obstacles) {
   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);
@@ -39315,11 +39301,12 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   const { grid, newStart, newEnd } = createGrid(start, end, allWaypoints);
   const finalStart = newStart || start;
   const finalEnd = newEnd || end;
-  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) => {
+  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);
     }

package/package.json

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