@rxflow/manhattan 0.0.1-alpha.8 → 0.0.1

package/esm/getManHattanPath.js

@@ -1,3 +1,4 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
@@ -8,12 +9,17 @@ 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; }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { getSmoothStepPath } from '@xyflow/react';
 import { Point, Rectangle } from "./geometry";
 import { ObstacleMap } from "./obstacle";
 import { resolveOptions } from "./options";
 import { findRoute } from "./pathfinder";
-import { pointsToPath, snapPathToGrid, parseSVGPath, simplifyPath } from "./svg";
+import { pointsToPath, parseSVGPath } from "./svg";
 import { getNodeDimensions, getNodePosition, pathIntersectsObstacles } from "./utils";
 
 /**
@@ -55,8 +61,17 @@ export function getManHattanPath(params) {
     _params$options = params.options,
     userOptions = _params$options === void 0 ? {} : _params$options;
 
-  // Resolve options
-  var options = resolveOptions(userOptions);
+  // Resolve options and add position information
+  var options = resolveOptions(_objectSpread(_objectSpread({}, userOptions), {}, {
+    sourcePosition: sourcePosition,
+    targetPosition: targetPosition
+  }));
+
+  // Direction control is automatically handled by getRectPoints:
+  // - When anchor is on an edge, only outward directions are allowed (via isDirectionOutward)
+  // - For sourcePosition="right": anchor on right edge -> only extends right
+  // - For targetPosition="left": anchor on left edge -> path approaches from right (outward from left)
+  // This ensures paths follow the sourcePosition and targetPosition constraints
 
   // Get source and target nodes
   var sourceNode = nodeLookup.get(sourceNodeId);
@@ -125,6 +140,19 @@ export function getManHattanPath(params) {
   console.log('[getManHattanPath] Source anchor:', "(".concat(sourceAnchor.x, ", ").concat(sourceAnchor.y, ")"));
   console.log('[getManHattanPath] Target anchor:', "(".concat(targetAnchor.x, ", ").concat(targetAnchor.y, ")"));
 
+  // If using smart point generation (sourcePosition/targetPosition specified),
+  // the route already contains the correct extension points, so skip manual processing
+  var useSmartPoints = sourcePosition || targetPosition;
+  if (useSmartPoints) {
+    console.log('[getManHattanPath] Using smart points, skipping manual extension point processing');
+    // Add source and target anchors to route
+    var _finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
+    console.log('[getManHattanPath] Final route:', _finalRoute.map(function (p) {
+      return "(".concat(p.x, ", ").concat(p.y, ")");
+    }));
+    return pointsToPath(_finalRoute, options.precision, options.borderRadius);
+  }
+
   // Remove extension points from route that were added by getRectPoints
   // We will add our own with fixed step distance
   var step = options.step;
@@ -168,8 +196,9 @@ export function getManHattanPath(params) {
     }
   }
 
-  // Insert extension point at source - always extend away from node edge by fixed step distance
+  // Insert extension point at source - always extend away from node edge by fixed distance
   if (route.length > 0) {
+    var extensionDistance = options.extensionDistance;
     var _firstPoint = route[0];
 
     // Determine which edge the source anchor is on
@@ -180,8 +209,8 @@ export function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (_onRight2) {
-      // Anchor on right edge - extend right by fixed step
-      var extendX = sourceAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      var extendX = sourceAnchor.x + extensionDistance;
       var extensionPoint = new Point(extendX, sourceAnchor.y);
       // Check if we need a corner point
       if (Math.abs(extensionPoint.y - _firstPoint.y) > tolerance) {
@@ -190,8 +219,8 @@ export function getManHattanPath(params) {
       route.unshift(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted source extension (right):', "(".concat(extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onLeft2) {
-      // Anchor on left edge - extend left by fixed step
-      var _extendX = sourceAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      var _extendX = sourceAnchor.x - extensionDistance;
       var _extensionPoint = new Point(_extendX, sourceAnchor.y);
       if (Math.abs(_extensionPoint.y - _firstPoint.y) > tolerance) {
         route.unshift(new Point(_extendX, _firstPoint.y));
@@ -199,8 +228,8 @@ export function getManHattanPath(params) {
       route.unshift(_extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (left):', "(".concat(_extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onBottom2) {
-      // Anchor on bottom edge - extend down by fixed step
-      var extendY = sourceAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      var extendY = sourceAnchor.y + extensionDistance;
       var _extensionPoint2 = new Point(sourceAnchor.x, extendY);
       if (Math.abs(_extensionPoint2.x - _firstPoint.x) > tolerance) {
         route.unshift(new Point(_firstPoint.x, extendY));
@@ -208,8 +237,8 @@ export function getManHattanPath(params) {
       route.unshift(_extensionPoint2);
       console.log('[getManHattanPath] Inserted source extension (down):', "(".concat(sourceAnchor.x, ", ").concat(extendY, ")"));
     } else if (_onTop2) {
-      // Anchor on top edge - extend up by fixed step
-      var _extendY = sourceAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      var _extendY = sourceAnchor.y - extensionDistance;
       var _extensionPoint3 = new Point(sourceAnchor.x, _extendY);
       if (Math.abs(_extensionPoint3.x - _firstPoint.x) > tolerance) {
         route.unshift(new Point(_firstPoint.x, _extendY));
@@ -219,51 +248,118 @@ export function getManHattanPath(params) {
     }
   }
 
-  // Insert extension point at target - always extend away from node edge by fixed step distance
+  // Remove redundant points after source extension
+  // If the first route point has the same x or y coordinate as the source anchor, it's redundant
+  if (route.length > 2) {
+    var firstRoutePoint = route[0]; // Extension point
+    var secondRoutePoint = route[1]; // Corner point (if exists)
+    var thirdRoutePoint = route[2]; // Original A* point
+
+    // Check if the third point (original A* point) is redundant
+    // It's redundant if it's on the same line as the corner point and can be skipped
+    var sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
+    var sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
+    if (sameX || sameY) {
+      // The third point is aligned with the source anchor, likely redundant
+      // Check if we can skip it by connecting corner point directly to the next point
+      if (route.length > 3) {
+        var fourthPoint = route[3];
+        // If corner point and fourth point form a straight line, remove the third point
+        var cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
+        var thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
+        if (cornerToThird && thirdToFourth) {
+          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdRoutePoint.x, ", ").concat(thirdRoutePoint.y, ")"));
+          route.splice(2, 1); // Remove the third point
+        }
+      }
+    }
+  }
+
+  // Optimize zigzag patterns BEFORE inserting target extension
+  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134)
+  // where the middle segment goes to target edge and then moves along it
+  // Use target bbox with padding (same as ObstacleMap)
+  var targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
+  console.log('[getManHattanPath] Route before zigzag check:', route.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+  console.log('[getManHattanPath] Target BBox with padding:', "x=".concat(targetBBoxWithPadding.x, ", y=").concat(targetBBoxWithPadding.y));
+  if (route.length >= 3) {
+    var _i = 0;
+    while (_i < route.length - 2) {
+      var p1 = route[_i];
+      var p2 = route[_i + 1];
+      var p3 = route[_i + 2];
+
+      // Check if p2 is on the target bbox edge (with padding)
+      var p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
+      var p2OnTargetRightEdge = Math.abs(p2.x - (targetBBoxWithPadding.x + targetBBoxWithPadding.width)) < tolerance;
+      var p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
+      var p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
+      var p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
+      console.log("[getManHattanPath] Checking i=".concat(_i, ": p2=(").concat(p2.x, ", ").concat(p2.y, "), onEdge=").concat(p2OnTargetEdge));
+      if (p2OnTargetEdge) {
+        // Check if p1 -> p2 -> p3 forms a zigzag
+        var p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
+        var p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
+        var p1ToP2Vertical = Math.abs(p1.x - p2.x) < tolerance;
+        var p2ToP3Horizontal = Math.abs(p2.y - p3.y) < tolerance;
+        console.log("[getManHattanPath] Zigzag pattern: H->V=".concat(p1ToP2Horizontal && p2ToP3Vertical, ", V->H=").concat(p1ToP2Vertical && p2ToP3Horizontal));
+        if (p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal) {
+          // We have a zigzag at target edge, remove p2 and p3
+          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(p2.x, ", ").concat(p2.y, ")"), "and (".concat(p3.x, ", ").concat(p3.y, ")"));
+          route.splice(_i + 1, 2); // Remove p2 and p3
+          continue;
+        }
+      }
+      _i++;
+    }
+  }
+
+  // Insert extension point at target - always extend away from node edge by fixed distance
   if (route.length > 0) {
-    var _step = options.step;
-    var _tolerance = 1;
+    var _extensionDistance = options.extensionDistance;
     var _lastPoint = route[route.length - 1];
 
     // Determine which edge the target anchor is on
-    var _onLeft3 = Math.abs(targetAnchor.x - targetBBox.x) < _tolerance;
-    var _onRight3 = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < _tolerance;
-    var _onTop3 = Math.abs(targetAnchor.y - targetBBox.y) < _tolerance;
-    var _onBottom3 = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < _tolerance;
+    var _onLeft3 = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
+    var _onRight3 = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    var _onTop3 = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
+    var _onBottom3 = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
 
     // Insert extension point and corner point to ensure orthogonal path
     if (_onLeft3) {
-      // Anchor on left edge - extend left by fixed step
-      var _extendX2 = targetAnchor.x - _step;
+      // Anchor on left edge - extend left by step + borderRadius
+      var _extendX2 = targetAnchor.x - _extensionDistance;
       var _extensionPoint4 = new Point(_extendX2, targetAnchor.y);
-      if (Math.abs(_extensionPoint4.y - _lastPoint.y) > _tolerance) {
+      if (Math.abs(_extensionPoint4.y - _lastPoint.y) > tolerance) {
         route.push(new Point(_extendX2, _lastPoint.y)); // Corner point
       }
       route.push(_extensionPoint4); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted target extension (left):', "(".concat(_extendX2, ", ").concat(targetAnchor.y, ")"));
     } else if (_onRight3) {
-      // Anchor on right edge - extend right by fixed step
-      var _extendX3 = targetAnchor.x + _step;
+      // Anchor on right edge - extend right by step + borderRadius
+      var _extendX3 = targetAnchor.x + _extensionDistance;
       var _extensionPoint5 = new Point(_extendX3, targetAnchor.y);
-      if (Math.abs(_extensionPoint5.y - _lastPoint.y) > _tolerance) {
+      if (Math.abs(_extensionPoint5.y - _lastPoint.y) > tolerance) {
         route.push(new Point(_extendX3, _lastPoint.y));
       }
       route.push(_extensionPoint5);
       console.log('[getManHattanPath] Inserted target extension (right):', "(".concat(_extendX3, ", ").concat(targetAnchor.y, ")"));
     } else if (_onTop3) {
-      // Anchor on top edge - extend up by fixed step
-      var _extendY2 = targetAnchor.y - _step;
+      // Anchor on top edge - extend up by step + borderRadius
+      var _extendY2 = targetAnchor.y - _extensionDistance;
       var _extensionPoint6 = new Point(targetAnchor.x, _extendY2);
-      if (Math.abs(_extensionPoint6.x - _lastPoint.x) > _tolerance) {
+      if (Math.abs(_extensionPoint6.x - _lastPoint.x) > tolerance) {
         route.push(new Point(_lastPoint.x, _extendY2));
       }
       route.push(_extensionPoint6);
       console.log('[getManHattanPath] Inserted target extension (up):', "(".concat(targetAnchor.x, ", ").concat(_extendY2, ")"));
     } else if (_onBottom3) {
-      // Anchor on bottom edge - extend down by fixed step
-      var _extendY3 = targetAnchor.y + _step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      var _extendY3 = targetAnchor.y + _extensionDistance;
       var _extensionPoint7 = new Point(targetAnchor.x, _extendY3);
-      if (Math.abs(_extensionPoint7.x - _lastPoint.x) > _tolerance) {
+      if (Math.abs(_extensionPoint7.x - _lastPoint.x) > tolerance) {
         route.push(new Point(_lastPoint.x, _extendY3));
       }
       route.push(_extensionPoint7);
@@ -271,22 +367,68 @@ export function getManHattanPath(params) {
     }
   }
 
-  // Add source and target anchors to route
-  var fullRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
-  console.log('[getManHattanPath] Full route:', fullRoute.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
+  // Remove redundant points before target extension
+  // Similar logic for target side
+  if (route.length > 2) {
+    var lastIdx = route.length - 1;
+    var lastRoutePoint = route[lastIdx]; // Extension point
+    var secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
+    var thirdLastPoint = route[lastIdx - 2]; // Original A* point
 
-  // Snap to grid if enabled
-  var finalRoute = fullRoute;
-  if (options.snapToGrid) {
-    // Use step size as grid size for snapping
-    finalRoute = snapPathToGrid(fullRoute, options.step);
+    // Check if the third-to-last point is redundant
+    var _sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    var _sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if (_sameX || _sameY) {
+      if (route.length > 3) {
+        var fourthLastPoint = route[lastIdx - 3];
+        var fourthToThird = Math.abs(fourthLastPoint.x - thirdLastPoint.x) < tolerance || Math.abs(fourthLastPoint.y - thirdLastPoint.y) < tolerance;
+        var thirdToSecond = Math.abs(thirdLastPoint.x - secondLastPoint.x) < tolerance || Math.abs(thirdLastPoint.y - secondLastPoint.y) < tolerance;
+        if (fourthToThird && thirdToSecond) {
+          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdLastPoint.x, ", ").concat(thirdLastPoint.y, ")"));
+          route.splice(lastIdx - 2, 1); // Remove the third-to-last point
+        }
+      }
+    }
   }
 
-  // Simplify path by removing collinear points
-  finalRoute = simplifyPath(finalRoute);
-  console.log('[getManHattanPath] Simplified route:', finalRoute.map(function (p) {
+  // Additional optimization: Remove unnecessary zigzag patterns near target
+  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134) -> (800, -134)
+  // where (815, 16) and (815, -134) form a zigzag at the target edge
+  var i = 0;
+  while (i < route.length - 2) {
+    var _p = route[i];
+    var _p2 = route[i + 1];
+    var _p3 = route[i + 2];
+
+    // Check if p2 is on the target bbox edge
+    var _p2OnTargetLeftEdge = Math.abs(_p2.x - targetBBox.x) < tolerance;
+    var _p2OnTargetRightEdge = Math.abs(_p2.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    var _p2OnTargetTopEdge = Math.abs(_p2.y - targetBBox.y) < tolerance;
+    var _p2OnTargetBottomEdge = Math.abs(_p2.y - (targetBBox.y + targetBBox.height)) < tolerance;
+    var _p2OnTargetEdge = _p2OnTargetLeftEdge || _p2OnTargetRightEdge || _p2OnTargetTopEdge || _p2OnTargetBottomEdge;
+    if (_p2OnTargetEdge) {
+      // Check if p1 -> p2 -> p3 forms a zigzag
+      var _p1ToP2Horizontal = Math.abs(_p.y - _p2.y) < tolerance;
+      var _p2ToP3Vertical = Math.abs(_p2.x - _p3.x) < tolerance;
+      if (_p1ToP2Horizontal && _p2ToP3Vertical && i < route.length - 3) {
+        // We have horizontal -> vertical at target edge
+        // Check if we can skip p2 and p3
+        var p4 = route[i + 3];
+        var p3ToP4Horizontal = Math.abs(_p3.y - p4.y) < tolerance;
+        if (p3ToP4Horizontal) {
+          // Pattern: horizontal -> vertical -> horizontal (zigzag)
+          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(_p2.x, ", ").concat(_p2.y, ")"), "and (".concat(_p3.x, ", ").concat(_p3.y, ")"));
+          route.splice(i + 1, 2); // Remove p2 and p3
+          continue;
+        }
+      }
+    }
+    i++;
+  }
+
+  // Add source and target anchors to route
+  var finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
+  console.log('[getManHattanPath] Final route:', finalRoute.map(function (p) {
     return "(".concat(p.x, ", ").concat(p.y, ")");
   }));
 

package/esm/obstacle/ObstacleMap.d.ts

@@ -22,7 +22,13 @@ export declare class ObstacleMap {
     private shrinkBBoxAroundAnchor;
     /**
      * Check if a point is accessible (not inside any obstacle)
+     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
      */
-    isAccessible(point: Point): boolean;
+    isAccessible(point: Point, checkRadius?: number): boolean;
+    /**
+     * Check accessibility using binary search optimization
+     * Tries step -> step/2 -> step/4 -> ... -> 1px
+     */
+    private isAccessibleWithBinarySearch;
 }
 //# sourceMappingURL=ObstacleMap.d.ts.map

package/esm/obstacle/ObstacleMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;gBAEhB,OAAO,EAAE,eAAe;IAMpC;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IAiEd;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6D9B;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;CA2CpC"}
+{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;gBAEhB,OAAO,EAAE,eAAe;IAMpC;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IAiEd;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6D9B;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAiD5D;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}

package/esm/obstacle/ObstacleMap.js

@@ -1,4 +1,7 @@
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+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; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -135,10 +138,12 @@ export var ObstacleMap = /*#__PURE__*/function () {
 
     /**
      * Check if a point is accessible (not inside any obstacle)
+     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
      */
   }, {
     key: "isAccessible",
     value: function isAccessible(point) {
+      var checkRadius = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       var key = point.clone().snapToGrid(this.mapGridSize).toString();
       var rects = this.map.get(key);
       if (!rects) {
@@ -161,6 +166,11 @@ export var ObstacleMap = /*#__PURE__*/function () {
           return true;
         }
       }
+
+      // If checkRadius is specified, use binary search to find accessible points
+      if (checkRadius > 0) {
+        return this.isAccessibleWithBinarySearch(point, checkRadius, rects);
+      }
       var accessible = rects.every(function (rect) {
         return !rect.containsPoint(point);
       });
@@ -178,6 +188,74 @@ export var ObstacleMap = /*#__PURE__*/function () {
       }
       return accessible;
     }
+
+    /**
+     * Check accessibility using binary search optimization
+     * Tries step -> step/2 -> step/4 -> ... -> 1px
+     */
+  }, {
+    key: "isAccessibleWithBinarySearch",
+    value: function isAccessibleWithBinarySearch(point, maxRadius, rects) {
+      // First check the point itself
+      if (rects.every(function (rect) {
+        return !rect.containsPoint(point);
+      })) {
+        return true;
+      }
+
+      // Binary search: start with step, then halve until we reach 1px
+      var radius = maxRadius;
+      var offsets = [{
+        dx: 1,
+        dy: 0
+      },
+      // right
+      {
+        dx: -1,
+        dy: 0
+      },
+      // left
+      {
+        dx: 0,
+        dy: 1
+      },
+      // down
+      {
+        dx: 0,
+        dy: -1
+      } // up
+      ];
+      while (radius >= 1) {
+        var _iterator = _createForOfIteratorHelper(offsets),
+          _step;
+        try {
+          var _loop = function _loop() {
+              var offset = _step.value;
+              var testPoint = new Point(point.x + offset.dx * radius, point.y + offset.dy * radius);
+              if (rects.every(function (rect) {
+                return !rect.containsPoint(testPoint);
+              })) {
+                return {
+                  v: true
+                };
+              }
+            },
+            _ret;
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            _ret = _loop();
+            if (_ret) return _ret.v;
+          }
+
+          // Halve the radius for next iteration
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        radius = Math.floor(radius / 2);
+      }
+      return false;
+    }
   }]);
   return ObstacleMap;
 }();

package/esm/options/defaults.d.ts

@@ -3,7 +3,7 @@ import type { ManhattanRouterOptions } from './types';
 /**
  * Default configuration for Manhattan router
  */
-export declare const defaults: Required<Omit<ManhattanRouterOptions, 'fallbackRoute'>>;
+export declare const defaults: Required<Omit<ManhattanRouterOptions, 'fallbackRoute' | 'sourcePosition' | 'targetPosition'>>;
 /**
  * Direction map - maps direction names to unit vectors
  */

package/esm/options/defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/options/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAa,MAAM,SAAS,CAAA;AAEhE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,sBAAsB,EAAE,eAAe,CAAC,CAkB5E,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/options/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAa,MAAM,SAAS,CAAA;AAEhE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,sBAAsB,EAAE,eAAe,GAAG,gBAAgB,GAAG,gBAAgB,CAAC,CAkBlH,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}

package/esm/options/defaults.js

@@ -12,9 +12,9 @@ export var defaults = {
   excludeNodes: [],
   excludeShapes: [],
   excludeTerminals: [],
-  padding: 0,
-  snapToGrid: true,
+  padding: 15,
   borderRadius: 5,
+  extensionDistance: 20,
   penalties: {
     0: 0,
     45: 5,

package/esm/options/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/options/resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAetE;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA+DpF"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/options/resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAetE;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CAiEpF"}

package/esm/options/resolver.js

@@ -33,7 +33,7 @@ export function normalizeAngle(angle) {
  * Resolve options by merging user options with defaults
  */
 export function resolveOptions() {
-  var _options$step, _options$maxLoopCount, _options$precision, _options$maxDirection, _options$startDirecti, _options$endDirection, _options$excludeNodes, _options$excludeShape, _options$excludeTermi, _options$snapToGrid, _options$borderRadius, _options$penalties, _options$padding;
+  var _options$step, _options$maxLoopCount, _options$precision, _options$maxDirection, _options$startDirecti, _options$endDirection, _options$excludeNodes, _options$excludeShape, _options$excludeTermi, _options$borderRadius, _options$extensionDis, _options$penalties, _options$padding;
   var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var step = (_options$step = options.step) !== null && _options$step !== void 0 ? _options$step : defaults.step;
   var maxLoopCount = (_options$maxLoopCount = options.maxLoopCount) !== null && _options$maxLoopCount !== void 0 ? _options$maxLoopCount : defaults.maxLoopCount;
@@ -44,8 +44,8 @@ export function resolveOptions() {
   var excludeNodes = (_options$excludeNodes = options.excludeNodes) !== null && _options$excludeNodes !== void 0 ? _options$excludeNodes : defaults.excludeNodes;
   var excludeShapes = (_options$excludeShape = options.excludeShapes) !== null && _options$excludeShape !== void 0 ? _options$excludeShape : defaults.excludeShapes;
   var excludeTerminals = (_options$excludeTermi = options.excludeTerminals) !== null && _options$excludeTermi !== void 0 ? _options$excludeTermi : defaults.excludeTerminals;
-  var snapToGrid = (_options$snapToGrid = options.snapToGrid) !== null && _options$snapToGrid !== void 0 ? _options$snapToGrid : defaults.snapToGrid;
   var borderRadius = (_options$borderRadius = options.borderRadius) !== null && _options$borderRadius !== void 0 ? _options$borderRadius : defaults.borderRadius;
+  var extensionDistance = (_options$extensionDis = options.extensionDistance) !== null && _options$extensionDis !== void 0 ? _options$extensionDis : defaults.extensionDistance;
   var penalties = (_options$penalties = options.penalties) !== null && _options$penalties !== void 0 ? _options$penalties : defaults.penalties;
   var fallbackRoute = options.fallbackRoute;
 
@@ -102,8 +102,10 @@ export function resolveOptions() {
     excludeShapes: excludeShapes,
     excludeTerminals: excludeTerminals,
     paddingBox: paddingBox,
-    snapToGrid: snapToGrid,
     borderRadius: borderRadius,
+    extensionDistance: extensionDistance,
+    sourcePosition: options.sourcePosition,
+    targetPosition: options.targetPosition,
     directionMap: directionMap,
     directions: directions,
     penalties: penalties,

package/esm/options/types.d.ts

@@ -89,17 +89,28 @@ export interface ManhattanRouterOptions {
         bottom: number;
         left: number;
     };
-    /**
-     * Whether the calculation results are aligned with the grid
-     * @default true
-     */
-    snapToGrid?: boolean;
     /**
      * Border radius for rounded corners at path turns (in pixels)
      * Set to 0 for sharp corners
      * @default 5
      */
     borderRadius?: number;
+    /**
+     * Extension distance from node edge for path start/end points (in pixels)
+     * This controls how far the path extends away from the node before turning
+     * @default 20
+     */
+    extensionDistance?: number;
+    /**
+     * Source position (from ReactFlow)
+     * Used for smart point generation
+     */
+    sourcePosition?: string;
+    /**
+     * Target position (from ReactFlow)
+     * Used for smart point generation
+     */
+    targetPosition?: string;
     /**
      * A penalty received for direction change
      */
@@ -130,8 +141,10 @@ export interface ResolvedOptions {
         width: number;
         height: number;
     };
-    snapToGrid: boolean;
     borderRadius: number;
+    extensionDistance: number;
+    sourcePosition?: string;
+    targetPosition?: string;
     directionMap: {
         top: Point;
         right: Point;

package/esm/options/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/options/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/options/types.ts"],"names":[],"mappings":"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"}

package/esm/pathfinder/findRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAe9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CAsNhB"}
+{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AA+I9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CAiThB"}