@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/pathfinder/findRoute.js

@@ -0,0 +1,395 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findRoute = findRoute;
+var _geometry = require("../geometry");
+var _SortedSet = require("./SortedSet");
+var _utils = require("../utils");
+/**
+ * Generate smart points based on position using extensionDistance and binary search
+ *
+ * Algorithm:
+ * 1. First try extensionDistance in the specified direction
+ * 2. If blocked, use binary search starting from step, halving until finding accessible point
+ * 3. For target points, approach from opposite direction
+ */
+function generateSmartPoints(anchor, bbox, position, grid, map, options, isTarget = false) {
+  const directionMap = {
+    'right': {
+      x: 1,
+      y: 0
+    },
+    'left': {
+      x: -1,
+      y: 0
+    },
+    'top': {
+      x: 0,
+      y: -1
+    },
+    'bottom': {
+      x: 0,
+      y: 1
+    }
+  };
+  const direction = directionMap[position];
+  if (!direction) {
+    console.warn(`[generateSmartPoints] Unknown position: ${position}, falling back to anchor`);
+    return [anchor];
+  }
+
+  // Both source and target extend in the specified direction
+  // - Source: extends away from node in sourcePosition direction
+  // - Target: extends away from node in targetPosition direction (path approaches from this direction)
+  const actualDirection = direction;
+  const points = [];
+
+  // 1. First try extensionDistance
+  const extensionPoint = new _geometry.Point(anchor.x + actualDirection.x * options.extensionDistance, anchor.y + actualDirection.y * options.extensionDistance).round(options.precision);
+  if (map.isAccessible(extensionPoint)) {
+    points.push(extensionPoint);
+    return points;
+  }
+
+  // 2. Step-based search with binary refinement
+  // First, extend outward by step increments until we find an accessible point
+  let stepMultiplier = 1;
+  let maxSteps = 20; // Prevent infinite loop
+  let foundAccessibleDistance = -1;
+  while (stepMultiplier <= maxSteps) {
+    const distance = stepMultiplier * options.step;
+    const testPoint = new _geometry.Point(anchor.x + actualDirection.x * distance, anchor.y + actualDirection.y * distance).round(options.precision);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      break;
+    }
+    stepMultiplier++;
+  }
+
+  // 3. If we found an accessible point, refine by binary search within the last step interval
+  if (foundAccessibleDistance > 0) {
+    const outerDistance = foundAccessibleDistance;
+    const innerDistance = foundAccessibleDistance - options.step;
+
+    // Binary search within the last step interval to find the closest accessible point
+    let left = innerDistance;
+    let right = outerDistance;
+    let bestDistance = outerDistance;
+    let binarySearchIterations = 0;
+    const maxBinarySearchIterations = 50; // Prevent infinite loop
+
+    // Binary search with precision of 1px
+    while (right - left > 1 && binarySearchIterations < maxBinarySearchIterations) {
+      binarySearchIterations++;
+      const mid = (left + right) / 2;
+      const testPoint = new _geometry.Point(anchor.x + actualDirection.x * mid, anchor.y + actualDirection.y * mid).round(options.precision);
+      if (map.isAccessible(testPoint)) {
+        bestDistance = mid;
+        right = mid;
+      } else {
+        left = mid;
+      }
+    }
+
+    // Use the best distance found
+    const finalPoint = new _geometry.Point(anchor.x + actualDirection.x * bestDistance, anchor.y + actualDirection.y * bestDistance).round(options.precision);
+    points.push(finalPoint);
+  } else {
+    // 4. If no accessible point found after maxSteps, use anchor as fallback
+    points.push(anchor);
+  }
+  return points;
+}
+
+/**
+ * Find route between two points using A* algorithm
+ */
+function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, options) {
+  const precision = options.precision;
+
+  // Round anchor points
+  const sourceEndpoint = (0, _utils.round)(sourceAnchor.clone(), precision);
+  const targetEndpoint = (0, _utils.round)(targetAnchor.clone(), precision);
+
+  // Get grid for this route
+  const grid = (0, _utils.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 _utils.ErrorRecovery.generateFallbackPath(sourceEndpoint, targetEndpoint);
+  }
+
+  // Get pathfinding points
+  const startPoint = sourceEndpoint;
+  const endPoint = targetEndpoint;
+
+  // Get start and end points around rectangles
+  // Use smart point generation based on position if available
+  let startPoints;
+  let endPoints;
+
+  // Generate smart start points based on sourcePosition
+  if (options.sourcePosition) {
+    startPoints = generateSmartPoints(startPoint, sourceBBox, options.sourcePosition, grid, map, options, false);
+  } else {
+    startPoints = (0, _utils.getRectPoints)(startPoint, sourceBBox, options.startDirections, grid, options);
+    // Take into account only accessible rect points
+    startPoints = startPoints.filter(p => map.isAccessible(p));
+  }
+
+  // Generate smart end points based on targetPosition
+  if (options.targetPosition) {
+    endPoints = generateSmartPoints(targetEndpoint, targetBBox, options.targetPosition, grid, map, options, true);
+  } else {
+    endPoints = (0, _utils.getRectPoints)(targetEndpoint, targetBBox, options.endDirections, grid, options);
+    // Take into account only accessible rect points
+    endPoints = endPoints.filter(p => map.isAccessible(p));
+  }
+
+  // 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 = [(0, _utils.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) {
+    return _utils.ErrorRecovery.generateFallbackPath(startPoint, endPoint);
+  }
+
+  // Initialize A* data structures
+  const openSet = new _SortedSet.SortedSet();
+  const points = new Map();
+  const parents = new Map();
+  const costs = new Map();
+
+  // Add all start points to open set
+  for (const startPoint of startPoints) {
+    const key = (0, _utils.getKey)(startPoint);
+    openSet.add(key, (0, _utils.getCost)(startPoint, endPoints));
+    points.set(key, startPoint);
+    costs.set(key, 0);
+  }
+  const previousRouteDirectionAngle = options.previousDirectionAngle;
+  const isPathBeginning = previousRouteDirectionAngle === undefined;
+
+  // Get directions with grid offsets
+  const directions = (0, _utils.getGridOffsets)(grid, options);
+  const numDirections = directions.length;
+
+  // Create set of end point keys for quick lookup
+  const endPointsKeys = new Set(endPoints.map(p => (0, _utils.getKey)(p)));
+
+  // Check if start and end points are the same
+  const sameStartEndPoints = startPoints.length === endPoints.length && startPoints.every((sp, i) => sp.equals(endPoints[i]));
+
+  // Calculate optimal path cost estimate for early termination
+  const optimalCostEstimate = startPoint.manhattanDistance(endPoint);
+  const earlyTerminationThreshold = options.performance?.earlyTermination ? 1.5 : Infinity;
+  let bestPathFound = null;
+  let bestPathCost = Infinity;
+
+  // Main A* loop
+  const maxIterations = options.maxLoopCount;
+  let iterationCount = 0;
+
+  // DEBUG: Log loop start
+  const loopStartTime = performance.now();
+  while (!openSet.isEmpty() && iterationCount < maxIterations) {
+    iterationCount++;
+
+    // DEBUG: Log every 10 iterations
+    if (iterationCount % 10 === 0) {
+      const elapsed = performance.now() - loopStartTime;
+      if (elapsed > 1000) {
+        console.error(`[findRoute] Loop running for ${elapsed.toFixed(0)}ms, iteration ${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 _utils.ErrorRecovery.generateFallbackPath(startPoint, endPoint);
+    }
+
+    // Get the closest item and mark it CLOSED
+    const currentKey = openSet.pop();
+    if (!currentKey) break;
+    const currentPoint = points.get(currentKey);
+    const currentParent = parents.get(currentKey);
+    const currentCost = costs.get(currentKey);
+    const isStartPoint = currentPoint.equals(startPoint);
+    const isRouteBeginning = currentParent === undefined;
+
+    // Calculate previous direction angle
+    let previousDirectionAngle;
+    if (!isRouteBeginning) {
+      previousDirectionAngle = (0, _utils.getDirectionAngle)(currentParent, currentPoint, numDirections, grid, options);
+    } else if (!isPathBeginning) {
+      previousDirectionAngle = previousRouteDirectionAngle;
+    } else if (!isStartPoint) {
+      previousDirectionAngle = (0, _utils.getDirectionAngle)(startPoint, currentPoint, numDirections, grid, options);
+    } else {
+      previousDirectionAngle = null;
+    }
+
+    // Check if we reached any endpoint
+    const skipEndCheck = isRouteBeginning && sameStartEndPoints;
+    if (!skipEndCheck && endPointsKeys.has(currentKey)) {
+      const route = (0, _utils.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 route;
+    }
+
+    // Explore neighbors in all directions
+    for (const direction of directions) {
+      const directionAngle = direction.angle;
+      const directionChange = (0, _utils.getDirectionChange)(previousDirectionAngle ?? 0, directionAngle);
+
+      // Don't use the point if direction changed too rapidly
+      if (!(isPathBeginning && isStartPoint) && directionChange > options.maxDirectionChange) {
+        continue;
+      }
+
+      // Calculate neighbor point and align to global grid
+      const rawNeighbor = currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0);
+
+      // Align to global grid for consistent path alignment
+      const neighborPoint = new _geometry.Point(Math.round(rawNeighbor.x / grid.x) * grid.x, Math.round(rawNeighbor.y / grid.y) * grid.y).round(precision);
+      const neighborKey = (0, _utils.getKey)(neighborPoint);
+
+      // Skip if closed or not accessible
+      if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+        continue;
+      }
+
+      // Check if we can reach any end point directly from this neighbor
+      // This allows connecting to end points that are not on the grid
+      let canReachEndPoint = false;
+      let reachableEndPoint = null;
+      for (const endPt of endPoints) {
+        const distanceToEnd = neighborPoint.manhattanDistance(endPt);
+
+        // If close enough to end point (within step distance), try direct connection
+        if (distanceToEnd < options.step * 1.5) {
+          // Check if we can move directly to the end point
+          const dx = endPt.x - neighborPoint.x;
+          const dy = endPt.y - neighborPoint.y;
+
+          // Allow direct connection if it's orthogonal or close to orthogonal
+          const isOrthogonal = Math.abs(dx) < 0.1 || Math.abs(dy) < 0.1;
+          if (isOrthogonal) {
+            const accessible = map.isAccessible(endPt);
+            if (accessible) {
+              canReachEndPoint = true;
+              reachableEndPoint = endPt;
+              break;
+            }
+          }
+        }
+      }
+
+      // If we can reach an end point directly, add it as the final step
+      if (canReachEndPoint && reachableEndPoint) {
+        const endKey = (0, _utils.getKey)(reachableEndPoint);
+        const endCost = neighborPoint.manhattanDistance(reachableEndPoint);
+        const totalCost = currentCost + direction.cost + endCost;
+        if (!openSet.isOpen(endKey) || totalCost < (costs.get(endKey) || Infinity)) {
+          points.set(endKey, reachableEndPoint);
+
+          // 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
+          if (!points.has(neighborKey)) {
+            points.set(neighborKey, neighborPoint);
+            parents.set(neighborKey, currentPoint);
+            costs.set(neighborKey, currentCost + direction.cost);
+          }
+
+          // Check if this is our target end point
+          if (endPointsKeys.has(endKey)) {
+            const route = (0, _utils.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 route;
+          }
+        }
+      }
+
+      // Check if neighbor is an end point (exact match)
+      if (endPointsKeys.has(neighborKey)) {
+        const isEndPoint = neighborPoint.equals(endPoint);
+        if (!isEndPoint) {
+          const endDirectionAngle = (0, _utils.getDirectionAngle)(neighborPoint, endPoint, numDirections, grid, options);
+          const endDirectionChange = (0, _utils.getDirectionChange)(directionAngle, endDirectionAngle);
+          if (endDirectionChange > options.maxDirectionChange) {
+            continue;
+          }
+        }
+      }
+
+      // Calculate costs
+      const neighborCost = direction.cost;
+      const neighborPenalty = isStartPoint ? 0 : options.penalties[directionChange] || 0;
+      const costFromStart = currentCost + neighborCost + neighborPenalty;
+
+      // Update if not in open set or found better path
+      if (!openSet.isOpen(neighborKey) || costFromStart < (costs.get(neighborKey) || Infinity)) {
+        points.set(neighborKey, neighborPoint);
+        parents.set(neighborKey, currentPoint);
+        costs.set(neighborKey, costFromStart);
+        openSet.add(neighborKey, costFromStart + (0, _utils.getCost)(neighborPoint, endPoints));
+      }
+    }
+
+    // Loop completed - check iteration count
+  }
+
+  // Return best path found if any
+  if (bestPathFound) {
+    return bestPathFound;
+  }
+
+  // No path found, try fallback
+  if (options.fallbackRoute) {
+    return options.fallbackRoute(startPoint, endPoint);
+  }
+
+  // Use ErrorRecovery to generate fallback path
+  return _utils.ErrorRecovery.generateFallbackPath(startPoint, endPoint);
+}

package/cjs/pathfinder/index.d.ts

@@ -0,0 +1,4 @@
+export { SortedSet } from './SortedSet';
+export { findRoute } from './findRoute';
+export { PathCache, generateCacheKey, getGlobalPathCache, resetGlobalPathCache, type CacheEntry, type PathCacheConfig, } from './PathCache';
+//# sourceMappingURL=index.d.ts.map

package/cjs/pathfinder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pathfinder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,eAAe,GACrB,MAAM,aAAa,CAAA"}

package/cjs/pathfinder/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PathCache", {
+  enumerable: true,
+  get: function () {
+    return _PathCache.PathCache;
+  }
+});
+Object.defineProperty(exports, "SortedSet", {
+  enumerable: true,
+  get: function () {
+    return _SortedSet.SortedSet;
+  }
+});
+Object.defineProperty(exports, "findRoute", {
+  enumerable: true,
+  get: function () {
+    return _findRoute.findRoute;
+  }
+});
+Object.defineProperty(exports, "generateCacheKey", {
+  enumerable: true,
+  get: function () {
+    return _PathCache.generateCacheKey;
+  }
+});
+Object.defineProperty(exports, "getGlobalPathCache", {
+  enumerable: true,
+  get: function () {
+    return _PathCache.getGlobalPathCache;
+  }
+});
+Object.defineProperty(exports, "resetGlobalPathCache", {
+  enumerable: true,
+  get: function () {
+    return _PathCache.resetGlobalPathCache;
+  }
+});
+var _SortedSet = require("./SortedSet");
+var _findRoute = require("./findRoute");
+var _PathCache = require("./PathCache");

package/cjs/svg/index.d.ts

@@ -0,0 +1,3 @@
+export { pointsToPath, snapPathToGrid } from './pathConverter';
+export { parseSVGPath, simplifyPath } from './pathParser';
+//# sourceMappingURL=index.d.ts.map

package/cjs/svg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svg/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA"}

package/cjs/svg/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "parseSVGPath", {
+  enumerable: true,
+  get: function () {
+    return _pathParser.parseSVGPath;
+  }
+});
+Object.defineProperty(exports, "pointsToPath", {
+  enumerable: true,
+  get: function () {
+    return _pathConverter.pointsToPath;
+  }
+});
+Object.defineProperty(exports, "simplifyPath", {
+  enumerable: true,
+  get: function () {
+    return _pathParser.simplifyPath;
+  }
+});
+Object.defineProperty(exports, "snapPathToGrid", {
+  enumerable: true,
+  get: function () {
+    return _pathConverter.snapPathToGrid;
+  }
+});
+var _pathConverter = require("./pathConverter");
+var _pathParser = require("./pathParser");

package/cjs/svg/pathConverter.d.ts

@@ -0,0 +1,23 @@
+import { Point } from '../geometry';
+/**
+ * Convert array of points to SVG path string
+ */
+export declare function pointsToPath(points: Point[], precision: number, borderRadius?: number): string;
+/**
+ * Convert array of points to SVG path string with cubic bezier curves
+ * Provides smoother corners than quadratic bezier
+ */
+export declare function pointsToPathCubic(points: Point[], precision: number, borderRadius?: number): string;
+/**
+ * Snap path to grid by aligning consecutive points
+ */
+export declare function snapPathToGrid(points: Point[], gridSize: number): Point[];
+/**
+ * Check if an SVG path contains rounded corners (Q or C commands)
+ */
+export declare function hasRoundedCorners(path: string): boolean;
+/**
+ * Count the number of corners in a path
+ */
+export declare function countCorners(points: Point[]): number;
+//# sourceMappingURL=pathConverter.d.ts.map

package/cjs/svg/pathConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathConverter.d.ts","sourceRoot":"","sources":["../../src/svg/pathConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AA4CnC;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM,CAwFjG;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM,CAgGtG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAgCzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAUpD"}