@rxflow/manhattan 0.0.1-alpha.8 → 0.0.1

package/cjs/geometry/Rectangle.d.ts

@@ -25,7 +25,7 @@ export declare class Rectangle {
      */
     getCorner(): Point;
     /**
-     * Check if a point is contained within this rectangle
+     * Check if a point is contained within this rectangle (interior only, excluding edges)
      */
     containsPoint(point: Point): boolean;
     /**

package/cjs/geometry/Rectangle.js

@@ -49,10 +49,10 @@ class Rectangle {
   }
 
   /**
-   * Check if a point is contained within this rectangle
+   * Check if a point is contained within this rectangle (interior only, excluding edges)
    */
   containsPoint(point) {
-    return point.x >= this.x && point.x <= this.x + this.width && point.y >= this.y && point.y <= this.y + this.height;
+    return point.x > this.x && point.x < this.x + this.width && point.y > this.y && point.y < this.y + this.height;
   }
 
   /**

package/cjs/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAsRvE"}
+{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAa,MAAM,WAAW,CAAA;AAM9E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAgbvE"}

package/cjs/getManHattanPath.js

@@ -51,8 +51,18 @@ function getManHattanPath(params) {
     options: userOptions = {}
   } = params;
 
-  // Resolve options
-  const options = (0, _options.resolveOptions)(userOptions);
+  // Resolve options and add position information
+  const options = (0, _options.resolveOptions)({
+    ...userOptions,
+    sourcePosition,
+    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
   const sourceNode = nodeLookup.get(sourceNodeId);
@@ -117,6 +127,17 @@ function getManHattanPath(params) {
   console.log('[getManHattanPath] Source anchor:', `(${sourceAnchor.x}, ${sourceAnchor.y})`);
   console.log('[getManHattanPath] Target anchor:', `(${targetAnchor.x}, ${targetAnchor.y})`);
 
+  // If using smart point generation (sourcePosition/targetPosition specified),
+  // the route already contains the correct extension points, so skip manual processing
+  const useSmartPoints = sourcePosition || targetPosition;
+  if (useSmartPoints) {
+    console.log('[getManHattanPath] Using smart points, skipping manual extension point processing');
+    // Add source and target anchors to route
+    const finalRoute = [sourceAnchor, ...route, targetAnchor];
+    console.log('[getManHattanPath] Final route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
+    return (0, _svg.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
   const step = options.step;
@@ -160,8 +181,9 @@ 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) {
+    const extensionDistance = options.extensionDistance;
     const firstPoint = route[0];
 
     // Determine which edge the source anchor is on
@@ -172,8 +194,8 @@ function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (onRight) {
-      // Anchor on right edge - extend right by fixed step
-      const extendX = sourceAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = sourceAnchor.x + extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
       // Check if we need a corner point
       if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
@@ -182,8 +204,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted source extension (right):', `(${extendX}, ${sourceAnchor.y})`);
     } else if (onLeft) {
-      // Anchor on left edge - extend left by fixed step
-      const extendX = sourceAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = sourceAnchor.x - extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
       if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
         route.unshift(new _geometry.Point(extendX, firstPoint.y));
@@ -191,8 +213,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (left):', `(${extendX}, ${sourceAnchor.y})`);
     } else if (onBottom) {
-      // Anchor on bottom edge - extend down by fixed step
-      const extendY = sourceAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = sourceAnchor.y + extensionDistance;
       const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
         route.unshift(new _geometry.Point(firstPoint.x, extendY));
@@ -200,8 +222,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (down):', `(${sourceAnchor.x}, ${extendY})`);
     } else if (onTop) {
-      // Anchor on top edge - extend up by fixed step
-      const extendY = sourceAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = sourceAnchor.y - extensionDistance;
       const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
         route.unshift(new _geometry.Point(firstPoint.x, extendY));
@@ -211,10 +233,75 @@ 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) {
+    const firstRoutePoint = route[0]; // Extension point
+    const secondRoutePoint = route[1]; // Corner point (if exists)
+    const 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
+    const sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
+    const 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) {
+        const fourthPoint = route[3];
+        // If corner point and fourth point form a straight line, remove the third point
+        const cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
+        const thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
+        if (cornerToThird && thirdToFourth) {
+          console.log('[getManHattanPath] Removing redundant point:', `(${thirdRoutePoint.x}, ${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)
+  const targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
+  console.log('[getManHattanPath] Route before zigzag check:', route.map(p => `(${p.x}, ${p.y})`));
+  console.log('[getManHattanPath] Target BBox with padding:', `x=${targetBBoxWithPadding.x}, y=${targetBBoxWithPadding.y}`);
+  if (route.length >= 3) {
+    let i = 0;
+    while (i < route.length - 2) {
+      const p1 = route[i];
+      const p2 = route[i + 1];
+      const p3 = route[i + 2];
+
+      // Check if p2 is on the target bbox edge (with padding)
+      const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
+      const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBoxWithPadding.x + targetBBoxWithPadding.width)) < tolerance;
+      const p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
+      const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
+      const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
+      console.log(`[getManHattanPath] Checking i=${i}: p2=(${p2.x}, ${p2.y}), onEdge=${p2OnTargetEdge}`);
+      if (p2OnTargetEdge) {
+        // Check if p1 -> p2 -> p3 forms a zigzag
+        const p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
+        const p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
+        const p1ToP2Vertical = Math.abs(p1.x - p2.x) < tolerance;
+        const p2ToP3Horizontal = Math.abs(p2.y - p3.y) < tolerance;
+        console.log(`[getManHattanPath] Zigzag pattern: H->V=${p1ToP2Horizontal && p2ToP3Vertical}, V->H=${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:', `(${p2.x}, ${p2.y})`, `and (${p3.x}, ${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) {
-    const step = options.step;
-    const tolerance = 1;
+    const extensionDistance = options.extensionDistance;
     const lastPoint = route[route.length - 1];
 
     // Determine which edge the target anchor is on
@@ -225,8 +312,8 @@ function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (onLeft) {
-      // Anchor on left edge - extend left by fixed step
-      const extendX = targetAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = targetAnchor.x - extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
       if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
         route.push(new _geometry.Point(extendX, lastPoint.y)); // Corner point
@@ -234,8 +321,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted target extension (left):', `(${extendX}, ${targetAnchor.y})`);
     } else if (onRight) {
-      // Anchor on right edge - extend right by fixed step
-      const extendX = targetAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = targetAnchor.x + extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
       if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
         route.push(new _geometry.Point(extendX, lastPoint.y));
@@ -243,8 +330,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint);
       console.log('[getManHattanPath] Inserted target extension (right):', `(${extendX}, ${targetAnchor.y})`);
     } else if (onTop) {
-      // Anchor on top edge - extend up by fixed step
-      const extendY = targetAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = targetAnchor.y - extensionDistance;
       const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
         route.push(new _geometry.Point(lastPoint.x, extendY));
@@ -252,8 +339,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint);
       console.log('[getManHattanPath] Inserted target extension (up):', `(${targetAnchor.x}, ${extendY})`);
     } else if (onBottom) {
-      // Anchor on bottom edge - extend down by fixed step
-      const extendY = targetAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = targetAnchor.y + extensionDistance;
       const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
         route.push(new _geometry.Point(lastPoint.x, extendY));
@@ -263,20 +350,68 @@ function getManHattanPath(params) {
     }
   }
 
-  // Add source and target anchors to route
-  const fullRoute = [sourceAnchor, ...route, targetAnchor];
-  console.log('[getManHattanPath] Full route:', fullRoute.map(p => `(${p.x}, ${p.y})`));
-
-  // Snap to grid if enabled
-  let finalRoute = fullRoute;
-  if (options.snapToGrid) {
-    // Use step size as grid size for snapping
-    finalRoute = (0, _svg.snapPathToGrid)(fullRoute, options.step);
+  // Remove redundant points before target extension
+  // Similar logic for target side
+  if (route.length > 2) {
+    const lastIdx = route.length - 1;
+    const lastRoutePoint = route[lastIdx]; // Extension point
+    const secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
+    const thirdLastPoint = route[lastIdx - 2]; // Original A* point
+
+    // Check if the third-to-last point is redundant
+    const sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    const sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if (sameX || sameY) {
+      if (route.length > 3) {
+        const fourthLastPoint = route[lastIdx - 3];
+        const fourthToThird = Math.abs(fourthLastPoint.x - thirdLastPoint.x) < tolerance || Math.abs(fourthLastPoint.y - thirdLastPoint.y) < tolerance;
+        const thirdToSecond = Math.abs(thirdLastPoint.x - secondLastPoint.x) < tolerance || Math.abs(thirdLastPoint.y - secondLastPoint.y) < tolerance;
+        if (fourthToThird && thirdToSecond) {
+          console.log('[getManHattanPath] Removing redundant point:', `(${thirdLastPoint.x}, ${thirdLastPoint.y})`);
+          route.splice(lastIdx - 2, 1); // Remove the third-to-last point
+        }
+      }
+    }
   }
 
-  // Simplify path by removing collinear points
-  finalRoute = (0, _svg.simplifyPath)(finalRoute);
-  console.log('[getManHattanPath] Simplified route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
+  // 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
+  let i = 0;
+  while (i < route.length - 2) {
+    const p1 = route[i];
+    const p2 = route[i + 1];
+    const p3 = route[i + 2];
+
+    // Check if p2 is on the target bbox edge
+    const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBox.x) < tolerance;
+    const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    const p2OnTargetTopEdge = Math.abs(p2.y - targetBBox.y) < tolerance;
+    const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBox.y + targetBBox.height)) < tolerance;
+    const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
+    if (p2OnTargetEdge) {
+      // Check if p1 -> p2 -> p3 forms a zigzag
+      const p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
+      const 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
+        const p4 = route[i + 3];
+        const p3ToP4Horizontal = Math.abs(p3.y - p4.y) < tolerance;
+        if (p3ToP4Horizontal) {
+          // Pattern: horizontal -> vertical -> horizontal (zigzag)
+          console.log('[getManHattanPath] Removing zigzag at target edge:', `(${p2.x}, ${p2.y})`, `and (${p3.x}, ${p3.y})`);
+          route.splice(i + 1, 2); // Remove p2 and p3
+          continue;
+        }
+      }
+    }
+    i++;
+  }
+
+  // Add source and target anchors to route
+  const finalRoute = [sourceAnchor, ...route, targetAnchor];
+  console.log('[getManHattanPath] Final route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
 
   // Convert to SVG path string
   return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);

package/cjs/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/cjs/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/cjs/obstacle/ObstacleMap.js

@@ -128,8 +128,9 @@ class ObstacleMap {
 
   /**
    * Check if a point is accessible (not inside any obstacle)
+   * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
    */
-  isAccessible(point) {
+  isAccessible(point, checkRadius = 0) {
     const key = point.clone().snapToGrid(this.mapGridSize).toString();
     const rects = this.map.get(key);
     if (!rects) {
@@ -152,6 +153,11 @@ class ObstacleMap {
         return true;
       }
     }
+
+    // If checkRadius is specified, use binary search to find accessible points
+    if (checkRadius > 0) {
+      return this.isAccessibleWithBinarySearch(point, checkRadius, rects);
+    }
     const accessible = rects.every(rect => !rect.containsPoint(point));
 
     // Debug: log points on the direct path
@@ -167,5 +173,51 @@ class ObstacleMap {
     }
     return accessible;
   }
+
+  /**
+   * Check accessibility using binary search optimization
+   * Tries step -> step/2 -> step/4 -> ... -> 1px
+   */
+  isAccessibleWithBinarySearch(point, maxRadius, rects) {
+    // First check the point itself
+    if (rects.every(rect => !rect.containsPoint(point))) {
+      return true;
+    }
+
+    // Binary search: start with step, then halve until we reach 1px
+    let radius = maxRadius;
+    const offsets = [{
+      dx: 1,
+      dy: 0
+    },
+    // right
+    {
+      dx: -1,
+      dy: 0
+    },
+    // left
+    {
+      dx: 0,
+      dy: 1
+    },
+    // down
+    {
+      dx: 0,
+      dy: -1
+    } // up
+    ];
+    while (radius >= 1) {
+      for (const offset of offsets) {
+        const testPoint = new _geometry.Point(point.x + offset.dx * radius, point.y + offset.dy * radius);
+        if (rects.every(rect => !rect.containsPoint(testPoint))) {
+          return true;
+        }
+      }
+
+      // Halve the radius for next iteration
+      radius = Math.floor(radius / 2);
+    }
+    return false;
+  }
 }
 exports.ObstacleMap = ObstacleMap;

package/cjs/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/cjs/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/cjs/options/defaults.js

@@ -18,9 +18,9 @@ const defaults = exports.defaults = {
   excludeNodes: [],
   excludeShapes: [],
   excludeTerminals: [],
-  padding: 0,
-  snapToGrid: true,
+  padding: 15,
   borderRadius: 5,
+  extensionDistance: 20,
   penalties: {
     0: 0,
     45: 5,

package/cjs/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/cjs/options/resolver.js

@@ -48,8 +48,8 @@ function resolveOptions(options = {}) {
   const excludeNodes = options.excludeNodes ?? _defaults.defaults.excludeNodes;
   const excludeShapes = options.excludeShapes ?? _defaults.defaults.excludeShapes;
   const excludeTerminals = options.excludeTerminals ?? _defaults.defaults.excludeTerminals;
-  const snapToGrid = options.snapToGrid ?? _defaults.defaults.snapToGrid;
   const borderRadius = options.borderRadius ?? _defaults.defaults.borderRadius;
+  const extensionDistance = options.extensionDistance ?? _defaults.defaults.extensionDistance;
   const penalties = options.penalties ?? _defaults.defaults.penalties;
   const fallbackRoute = options.fallbackRoute;
 
@@ -106,8 +106,10 @@ function resolveOptions(options = {}) {
     excludeShapes,
     excludeTerminals,
     paddingBox,
-    snapToGrid,
     borderRadius,
+    extensionDistance,
+    sourcePosition: options.sourcePosition,
+    targetPosition: options.targetPosition,
     directionMap: _defaults.directionMap,
     directions,
     penalties,

package/cjs/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/cjs/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/cjs/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"}