@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/pathfinder/findRoute.js

@@ -3,7 +3,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import { Point } from "../geometry";
 import { SortedSet } from "./SortedSet";
-import { getGrid, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute } from "../utils";
+import { getGrid, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute, ErrorRecovery } from "../utils";
 
 /**
  * Generate smart points based on position using extensionDistance and binary search
@@ -47,27 +47,21 @@ function generateSmartPoints(anchor, bbox, position, grid, map, options) {
 
   // 1. First try extensionDistance
   var extensionPoint = new Point(anchor.x + actualDirection.x * options.extensionDistance, anchor.y + actualDirection.y * options.extensionDistance).round(options.precision);
-  console.log("[generateSmartPoints] ".concat(isTarget ? 'Target' : 'Source', " position=").concat(position, ", trying extension point: (").concat(extensionPoint.x, ", ").concat(extensionPoint.y, ")"));
   if (map.isAccessible(extensionPoint)) {
     points.push(extensionPoint);
-    console.log("[generateSmartPoints] Extension point is accessible");
     return points;
   }
-  console.log("[generateSmartPoints] Extension point blocked, using step-based search");
 
   // 2. Step-based search with binary refinement
   // First, extend outward by step increments until we find an accessible point
   var stepMultiplier = 1;
   var maxSteps = 20; // Prevent infinite loop
   var foundAccessibleDistance = -1;
-  console.log("[generateSmartPoints] Starting outward search with step=".concat(options.step));
   while (stepMultiplier <= maxSteps) {
     var distance = stepMultiplier * options.step;
     var testPoint = new Point(anchor.x + actualDirection.x * distance, anchor.y + actualDirection.y * distance).round(options.precision);
-    console.log("[generateSmartPoints] Testing ".concat(stepMultiplier, "*step (distance=").concat(distance, "): (").concat(testPoint.x, ", ").concat(testPoint.y, ")"));
     if (map.isAccessible(testPoint)) {
       foundAccessibleDistance = distance;
-      console.log("[generateSmartPoints] Found accessible point at ".concat(stepMultiplier, "*step (distance=").concat(distance, ")"));
       break;
     }
     stepMultiplier++;
@@ -77,35 +71,32 @@ function generateSmartPoints(anchor, bbox, position, grid, map, options) {
   if (foundAccessibleDistance > 0) {
     var outerDistance = foundAccessibleDistance;
     var innerDistance = foundAccessibleDistance - options.step;
-    console.log("[generateSmartPoints] Refining between ".concat(innerDistance, " and ").concat(outerDistance));
 
     // Binary search within the last step interval to find the closest accessible point
     var left = innerDistance;
     var right = outerDistance;
     var bestDistance = outerDistance;
+    var binarySearchIterations = 0;
+    var maxBinarySearchIterations = 50; // Prevent infinite loop
 
     // Binary search with precision of 1px
-    while (right - left > 1) {
+    while (right - left > 1 && binarySearchIterations < maxBinarySearchIterations) {
+      binarySearchIterations++;
       var mid = (left + right) / 2;
       var _testPoint = new Point(anchor.x + actualDirection.x * mid, anchor.y + actualDirection.y * mid).round(options.precision);
-      console.log("[generateSmartPoints] Binary search testing distance ".concat(mid.toFixed(1), ": (").concat(_testPoint.x, ", ").concat(_testPoint.y, ")"));
       if (map.isAccessible(_testPoint)) {
         bestDistance = mid;
         right = mid;
-        console.log("[generateSmartPoints] Point accessible, searching closer (right=".concat(right, ")"));
       } else {
         left = mid;
-        console.log("[generateSmartPoints] Point blocked, searching further (left=".concat(left, ")"));
       }
     }
 
     // Use the best distance found
     var finalPoint = new Point(anchor.x + actualDirection.x * bestDistance, anchor.y + actualDirection.y * bestDistance).round(options.precision);
     points.push(finalPoint);
-    console.log("[generateSmartPoints] Final point at distance ".concat(bestDistance, ": (").concat(finalPoint.x, ", ").concat(finalPoint.y, ")"));
   } else {
     // 4. If no accessible point found after maxSteps, use anchor as fallback
-    console.log("[generateSmartPoints] No accessible point found after ".concat(maxSteps, " steps, using anchor: (").concat(anchor.x, ", ").concat(anchor.y, ")"));
     points.push(anchor);
   }
   return points;
@@ -115,6 +106,7 @@ function generateSmartPoints(anchor, bbox, position, grid, map, options) {
  * Find route between two points using A* algorithm
  */
 export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, options) {
+  var _options$performance;
   var precision = options.precision;
 
   // Round anchor points
@@ -124,6 +116,12 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
   // Get grid for this route
   var grid = getGrid(options.step, sourceEndpoint, targetEndpoint);
 
+  // DEBUG: Check for invalid grid values
+  if (grid.x === 0 || grid.y === 0 || !isFinite(grid.x) || !isFinite(grid.y)) {
+    console.error('[findRoute] INVALID GRID:', grid, 'step:', options.step);
+    return ErrorRecovery.generateFallbackPath(sourceEndpoint, targetEndpoint);
+  }
+
   // Get pathfinding points
   var startPoint = sourceEndpoint;
   var endPoint = targetEndpoint;
@@ -136,14 +134,8 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
   // Generate smart start points based on sourcePosition
   if (options.sourcePosition) {
     startPoints = generateSmartPoints(startPoint, sourceBBox, options.sourcePosition, grid, map, options, false);
-    console.log('[findRoute] Start points from smart generation:', startPoints.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
   } else {
     startPoints = getRectPoints(startPoint, sourceBBox, options.startDirections, grid, options);
-    console.log('[findRoute] Start points from getRectPoints:', startPoints.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
     // Take into account only accessible rect points
     startPoints = startPoints.filter(function (p) {
       return map.isAccessible(p);
@@ -153,33 +145,24 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
   // Generate smart end points based on targetPosition
   if (options.targetPosition) {
     endPoints = generateSmartPoints(targetEndpoint, targetBBox, options.targetPosition, grid, map, options, true);
-    console.log('[findRoute] End points from smart generation:', endPoints.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
   } else {
     endPoints = getRectPoints(targetEndpoint, targetBBox, options.endDirections, grid, options);
-    console.log('[findRoute] End points from getRectPoints:', endPoints.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
     // Take into account only accessible rect points
     endPoints = endPoints.filter(function (p) {
       return map.isAccessible(p);
     });
   }
-  console.log('[findRoute] Start points after filter:', startPoints.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
-  console.log('[findRoute] End points after filter:', endPoints.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
 
   // Ensure we always have at least the anchor points
   // This handles edge cases where anchor is on the node boundary
   if (startPoints.length === 0) {
     startPoints = [round(startPoint, precision)];
   }
+
+  // CRITICAL: If no accessible end points found, use fallback immediately
+  // This prevents A* from running 5000 iterations searching for unreachable points
   if (endPoints.length === 0) {
-    endPoints = [round(endPoint, precision)];
+    return ErrorRecovery.generateFallbackPath(startPoint, endPoint);
   }
 
   // Initialize A* data structures
@@ -221,9 +204,35 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
     return sp.equals(endPoints[i]);
   });
 
+  // Calculate optimal path cost estimate for early termination
+  var optimalCostEstimate = startPoint.manhattanDistance(endPoint);
+  var earlyTerminationThreshold = (_options$performance = options.performance) !== null && _options$performance !== void 0 && _options$performance.earlyTermination ? 1.5 : Infinity;
+  var bestPathFound = null;
+  var bestPathCost = Infinity;
+
   // Main A* loop
-  var loopsRemaining = options.maxLoopCount;
-  while (!openSet.isEmpty() && loopsRemaining > 0) {
+  var maxIterations = options.maxLoopCount;
+  var iterationCount = 0;
+
+  // DEBUG: Log loop start
+  var loopStartTime = performance.now();
+  while (!openSet.isEmpty() && iterationCount < maxIterations) {
+    iterationCount++;
+
+    // DEBUG: Log every 10 iterations
+    if (iterationCount % 10 === 0) {
+      var elapsed = performance.now() - loopStartTime;
+      if (elapsed > 1000) {
+        console.error("[findRoute] Loop running for ".concat(elapsed.toFixed(0), "ms, iteration ").concat(iterationCount));
+      }
+    }
+
+    // Early termination: if we've searched too many points without finding a path,
+    // the path is likely blocked or very complex - use fallback
+    if (iterationCount > 2000 && bestPathFound === null) {
+      return ErrorRecovery.generateFallbackPath(startPoint, endPoint);
+    }
+
     // Get the closest item and mark it CLOSED
     var currentKey = openSet.pop();
     if (!currentKey) break;
@@ -248,8 +257,21 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
     // Check if we reached any endpoint
     var skipEndCheck = isRouteBeginning && sameStartEndPoints;
     if (!skipEndCheck && endPointsKeys.has(currentKey)) {
+      var route = reconstructRoute(parents, points, currentPoint, startPoint, endPoint);
+
+      // Early termination: if path cost is within threshold of optimal, return immediately
+      if (currentCost <= optimalCostEstimate * earlyTerminationThreshold) {
+        options.previousDirectionAngle = previousDirectionAngle;
+        return route;
+      }
+
+      // Track best path found so far
+      if (currentCost < bestPathCost) {
+        bestPathCost = currentCost;
+        bestPathFound = route;
+      }
       options.previousDirectionAngle = previousDirectionAngle;
-      return reconstructRoute(parents, points, currentPoint, startPoint, endPoint);
+      return route;
     }
 
     // Explore neighbors in all directions
@@ -298,10 +320,13 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
 
               // Allow direct connection if it's orthogonal or close to orthogonal
               var isOrthogonal = Math.abs(dx) < 0.1 || Math.abs(dy) < 0.1;
-              if (isOrthogonal && map.isAccessible(endPt)) {
-                canReachEndPoint = true;
-                reachableEndPoint = endPt;
-                break;
+              if (isOrthogonal) {
+                var accessible = map.isAccessible(endPt);
+                if (accessible) {
+                  canReachEndPoint = true;
+                  reachableEndPoint = endPt;
+                  break;
+                }
               }
             }
           }
@@ -318,7 +343,15 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
           var totalCost = currentCost + direction.cost + endCost;
           if (!openSet.isOpen(endKey) || totalCost < (costs.get(endKey) || Infinity)) {
             points.set(endKey, reachableEndPoint);
-            parents.set(endKey, neighborPoint);
+
+            // CRITICAL FIX: Don't set parent if neighbor and endpoint are the same
+            // This prevents circular reference in reconstructRoute
+            if (!neighborPoint.equals(reachableEndPoint)) {
+              parents.set(endKey, neighborPoint);
+            } else {
+              // If neighbor IS the endpoint, use currentPoint as parent
+              parents.set(endKey, currentPoint);
+            }
             costs.set(endKey, totalCost);
 
             // Also add the neighbor point if not already added
@@ -330,8 +363,21 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
 
             // Check if this is our target end point
             if (endPointsKeys.has(endKey)) {
+              var _route = reconstructRoute(parents, points, reachableEndPoint, startPoint, endPoint);
+
+              // Early termination check
+              if (totalCost <= optimalCostEstimate * earlyTerminationThreshold) {
+                options.previousDirectionAngle = directionAngle;
+                return _route;
+              }
+
+              // Track best path
+              if (totalCost < bestPathCost) {
+                bestPathCost = totalCost;
+                bestPathFound = _route;
+              }
               options.previousDirectionAngle = directionAngle;
-              return reconstructRoute(parents, points, reachableEndPoint, startPoint, endPoint);
+              return _route;
             }
           }
         }
@@ -361,17 +407,25 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
           openSet.add(neighborKey, costFromStart + getCost(neighborPoint, endPoints));
         }
       }
+
+      // Loop completed - check iteration count
     } catch (err) {
       _iterator2.e(err);
     } finally {
       _iterator2.f();
     }
-    loopsRemaining -= 1;
+  }
+
+  // Return best path found if any
+  if (bestPathFound) {
+    return bestPathFound;
   }
 
   // No path found, try fallback
   if (options.fallbackRoute) {
     return options.fallbackRoute(startPoint, endPoint);
   }
-  return null;
+
+  // Use ErrorRecovery to generate fallback path
+  return ErrorRecovery.generateFallbackPath(startPoint, endPoint);
 }

package/esm/pathfinder/index.js

@@ -1,2 +1,3 @@
 export { SortedSet } from "./SortedSet";
-export { findRoute } from "./findRoute";
+export { findRoute } from "./findRoute";
+export { PathCache, generateCacheKey, getGlobalPathCache, resetGlobalPathCache } from "./PathCache";

package/esm/svg/pathConverter.js

@@ -4,6 +4,42 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * Check if three points form a corner (direction change)
+ */
+function isCorner(prev, current, next) {
+  var dx1 = current.x - prev.x;
+  var dy1 = current.y - prev.y;
+  var dx2 = next.x - current.x;
+  var dy2 = next.y - current.y;
+
+  // Check if direction changes (not collinear)
+  // For Manhattan paths, this means one segment is horizontal and the other is vertical
+  var isHorizontal1 = Math.abs(dy1) < 0.001;
+  var isVertical1 = Math.abs(dx1) < 0.001;
+  var isHorizontal2 = Math.abs(dy2) < 0.001;
+  var isVertical2 = Math.abs(dx2) < 0.001;
+
+  // Corner exists if one segment is horizontal and the other is vertical
+  return isHorizontal1 && isVertical2 || isVertical1 && isHorizontal2;
+}
+
+/**
+ * Calculate optimal border radius for a corner
+ * Ensures the radius doesn't exceed half the length of adjacent segments
+ */
+function calculateOptimalRadius(prev, current, next, maxRadius) {
+  var dx1 = current.x - prev.x;
+  var dy1 = current.y - prev.y;
+  var dx2 = next.x - current.x;
+  var dy2 = next.y - current.y;
+  var dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+  var dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+
+  // Use the smaller of maxRadius or half the segment length
+  return Math.min(maxRadius, dist1 / 2, dist2 / 2);
+}
+
 /**
  * Convert array of points to SVG path string
  */
@@ -38,6 +74,13 @@ export function pointsToPath(points, precision) {
     var current = points[_i];
     var next = points[_i + 1];
 
+    // Check if this is actually a corner
+    if (!isCorner(prev, current, next)) {
+      // Not a corner, just draw a line to current point
+      path += " L ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y));
+      continue;
+    }
+
     // Calculate direction vectors
     var dx1 = current.x - prev.x;
     var dy1 = current.y - prev.y;
@@ -49,7 +92,13 @@ export function pointsToPath(points, precision) {
     var dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
 
     // Use the smaller of borderRadius or half the segment length
-    var radius = Math.min(borderRadius, dist1 / 2, dist2 / 2);
+    var radius = calculateOptimalRadius(prev, current, next, borderRadius);
+
+    // Skip if radius is too small
+    if (radius < 0.5) {
+      path += " L ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y));
+      continue;
+    }
 
     // Normalize direction vectors
     var ndx1 = dx1 / dist1;
@@ -83,6 +132,106 @@ export function pointsToPath(points, precision) {
   return path;
 }
 
+/**
+ * Convert array of points to SVG path string with cubic bezier curves
+ * Provides smoother corners than quadratic bezier
+ */
+export function pointsToPathCubic(points, precision) {
+  var borderRadius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  if (points.length === 0) {
+    return '';
+  }
+  var factor = Math.pow(10, precision);
+  var roundCoord = function roundCoord(value) {
+    return Math.round(value * factor) / factor;
+  };
+
+  // If no border radius or only 2 points, use simple line path
+  if (borderRadius === 0 || points.length <= 2) {
+    var _firstPoint2 = points[0];
+    var _path2 = "M ".concat(roundCoord(_firstPoint2.x), " ").concat(roundCoord(_firstPoint2.y));
+    for (var i = 1; i < points.length; i++) {
+      var point = points[i];
+      _path2 += " L ".concat(roundCoord(point.x), " ").concat(roundCoord(point.y));
+    }
+    return _path2;
+  }
+
+  // Start with M (moveTo) command for first point
+  var firstPoint = points[0];
+  var path = "M ".concat(roundCoord(firstPoint.x), " ").concat(roundCoord(firstPoint.y));
+
+  // Process each segment with rounded corners using cubic bezier
+  for (var _i2 = 1; _i2 < points.length - 1; _i2++) {
+    var prev = points[_i2 - 1];
+    var current = points[_i2];
+    var next = points[_i2 + 1];
+
+    // Check if this is actually a corner
+    if (!isCorner(prev, current, next)) {
+      path += " L ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y));
+      continue;
+    }
+
+    // Calculate direction vectors
+    var dx1 = current.x - prev.x;
+    var dy1 = current.y - prev.y;
+    var dx2 = next.x - current.x;
+    var dy2 = next.y - current.y;
+
+    // Calculate distances
+    var dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    var dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+
+    // Use the smaller of borderRadius or half the segment length
+    var radius = calculateOptimalRadius(prev, current, next, borderRadius);
+
+    // Skip if radius is too small
+    if (radius < 0.5) {
+      path += " L ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y));
+      continue;
+    }
+
+    // Normalize direction vectors
+    var ndx1 = dx1 / dist1;
+    var ndy1 = dy1 / dist1;
+    var ndx2 = dx2 / dist2;
+    var ndy2 = dy2 / dist2;
+
+    // Calculate the point before the corner
+    var beforeCorner = {
+      x: current.x - ndx1 * radius,
+      y: current.y - ndy1 * radius
+    };
+
+    // Calculate the point after the corner
+    var afterCorner = {
+      x: current.x + ndx2 * radius,
+      y: current.y + ndy2 * radius
+    };
+
+    // Draw line to the point before corner
+    path += " L ".concat(roundCoord(beforeCorner.x), " ").concat(roundCoord(beforeCorner.y));
+
+    // Draw cubic bezier curve for smoother rounded corner
+    // Control points are positioned to create a smooth arc
+    var cp1 = {
+      x: beforeCorner.x + ndx1 * radius * 0.55,
+      y: beforeCorner.y + ndy1 * radius * 0.55
+    };
+    var cp2 = {
+      x: afterCorner.x - ndx2 * radius * 0.55,
+      y: afterCorner.y - ndy2 * radius * 0.55
+    };
+    path += " C ".concat(roundCoord(cp1.x), " ").concat(roundCoord(cp1.y), " ").concat(roundCoord(cp2.x), " ").concat(roundCoord(cp2.y), " ").concat(roundCoord(afterCorner.x), " ").concat(roundCoord(afterCorner.y));
+  }
+
+  // Draw line to the last point
+  var lastPoint = points[points.length - 1];
+  path += " L ".concat(roundCoord(lastPoint.x), " ").concat(roundCoord(lastPoint.y));
+  return path;
+}
+
 /**
  * Snap path to grid by aligning consecutive points
  */
@@ -115,4 +264,24 @@ export function snapPathToGrid(points, gridSize) {
     }
   }
   return snappedPoints;
+}
+
+/**
+ * Check if an SVG path contains rounded corners (Q or C commands)
+ */
+export function hasRoundedCorners(path) {
+  return /[QC]\s/.test(path);
+}
+
+/**
+ * Count the number of corners in a path
+ */
+export function countCorners(points) {
+  var corners = 0;
+  for (var i = 1; i < points.length - 1; i++) {
+    if (isCorner(points[i - 1], points[i], points[i + 1])) {
+      corners++;
+    }
+  }
+  return corners;
 }